1
2
3
4 package hcn
5
6 import (
7 "encoding/json"
8 "fmt"
9 "testing"
10
11 "github.com/Microsoft/go-winio/pkg/guid"
12 "github.com/Microsoft/hcsshim/internal/cni"
13 )
14
15 func newGUID(t *testing.T) guid.GUID {
16 t.Helper()
17 g, err := guid.NewV4()
18 if err != nil {
19 t.Fatal(err)
20 }
21 return g
22 }
23
24 func TestNewNamespace(t *testing.T) {
25 _ = NewNamespace(NamespaceTypeHost)
26 _ = NewNamespace(NamespaceTypeHostDefault)
27 _ = NewNamespace(NamespaceTypeGuest)
28 _ = NewNamespace(NamespaceTypeGuestDefault)
29 }
30
31 func TestCreateDeleteNamespace(t *testing.T) {
32 namespace, err := HcnCreateTestNamespace()
33 if err != nil {
34 t.Fatal(err)
35 }
36
37 jsonString, err := json.Marshal(namespace)
38 if err != nil {
39 t.Fatal(err)
40 }
41 fmt.Printf("Namespace JSON:\n%s \n", jsonString)
42
43 err = namespace.Delete()
44 if err != nil {
45 t.Fatal(err)
46 }
47 }
48
49 func TestCreateDeleteNamespaceGuest(t *testing.T) {
50 namespace := &HostComputeNamespace{
51 Type: NamespaceTypeGuestDefault,
52 SchemaVersion: SchemaVersion{
53 Major: 2,
54 Minor: 0,
55 },
56 }
57
58 hnsNamespace, err := namespace.Create()
59 if err != nil {
60 t.Fatal(err)
61 }
62
63 err = hnsNamespace.Delete()
64 if err != nil {
65 t.Fatal(err)
66 }
67 }
68
69 func TestGetNamespaceById(t *testing.T) {
70 namespace, err := HcnCreateTestNamespace()
71 if err != nil {
72 t.Fatal(err)
73 }
74
75 foundNamespace, err := GetNamespaceByID(namespace.Id)
76 if err != nil {
77 t.Fatal(err)
78 }
79 if foundNamespace == nil {
80 t.Fatal("No namespace found")
81 }
82
83 err = namespace.Delete()
84 if err != nil {
85 t.Fatal(err)
86 }
87 }
88
89 func TestListNamespaces(t *testing.T) {
90 namespace, err := HcnCreateTestNamespace()
91 if err != nil {
92 t.Fatal(err)
93 }
94
95 foundNamespaces, err := ListNamespaces()
96 if err != nil {
97 t.Fatal(err)
98 }
99 if len(foundNamespaces) == 0 {
100 t.Fatal("No Namespaces found")
101 }
102
103 err = namespace.Delete()
104 if err != nil {
105 t.Fatal(err)
106 }
107 }
108
109 func TestGetNamespaceEndpointIds(t *testing.T) {
110 network, err := HcnCreateTestNATNetwork()
111 if err != nil {
112 t.Fatal(err)
113 }
114 endpoint, err := HcnCreateTestEndpoint(network)
115 if err != nil {
116 t.Fatal(err)
117 }
118 namespace, err := HcnCreateTestNamespace()
119 if err != nil {
120 t.Fatal(err)
121 }
122
123 err = endpoint.NamespaceAttach(namespace.Id)
124 if err != nil {
125 t.Fatal(err)
126 }
127 foundEndpoints, err := GetNamespaceEndpointIds(namespace.Id)
128 if err != nil {
129 t.Fatal(err)
130 }
131 if len(foundEndpoints) == 0 {
132 t.Fatal("No Endpoint found")
133 }
134 err = endpoint.NamespaceDetach(namespace.Id)
135 if err != nil {
136 t.Fatal(err)
137 }
138
139 err = namespace.Delete()
140 if err != nil {
141 t.Fatal(err)
142 }
143 err = endpoint.Delete()
144 if err != nil {
145 t.Fatal(err)
146 }
147 err = network.Delete()
148 if err != nil {
149 t.Fatal(err)
150 }
151 }
152
153 func TestGetNamespaceContainers(t *testing.T) {
154 namespace, err := HcnCreateTestNamespace()
155 if err != nil {
156 t.Fatal(err)
157 }
158
159 foundEndpoints, err := GetNamespaceContainerIds(namespace.Id)
160 if err != nil {
161 t.Fatal(err)
162 }
163 if len(foundEndpoints) != 0 {
164 t.Fatal("Found containers when none should exist")
165 }
166
167 err = namespace.Delete()
168 if err != nil {
169 t.Fatal(err)
170 }
171 }
172
173 func TestAddRemoveNamespaceEndpoint(t *testing.T) {
174 network, err := HcnCreateTestNATNetwork()
175 if err != nil {
176 t.Fatal(err)
177 }
178 endpoint, err := HcnCreateTestEndpoint(network)
179 if err != nil {
180 t.Fatal(err)
181 }
182 namespace, err := HcnCreateTestNamespace()
183 if err != nil {
184 t.Fatal(err)
185 }
186
187 err = AddNamespaceEndpoint(namespace.Id, endpoint.Id)
188 if err != nil {
189 t.Fatal(err)
190 }
191 foundEndpoints, err := GetNamespaceEndpointIds(namespace.Id)
192 if err != nil {
193 t.Fatal(err)
194 }
195 if len(foundEndpoints) == 0 {
196 t.Fatal("No Endpoint found")
197 }
198 err = RemoveNamespaceEndpoint(namespace.Id, endpoint.Id)
199 if err != nil {
200 t.Fatal(err)
201 }
202
203 err = namespace.Delete()
204 if err != nil {
205 t.Fatal(err)
206 }
207 err = endpoint.Delete()
208 if err != nil {
209 t.Fatal(err)
210 }
211 err = network.Delete()
212 if err != nil {
213 t.Fatal(err)
214 }
215 }
216
217 func TestModifyNamespaceSettings(t *testing.T) {
218 network, err := HcnCreateTestNATNetwork()
219 if err != nil {
220 t.Fatal(err)
221 }
222 endpoint, err := HcnCreateTestEndpoint(network)
223 if err != nil {
224 t.Fatal(err)
225 }
226 namespace, err := HcnCreateTestNamespace()
227 if err != nil {
228 t.Fatal(err)
229 }
230
231 mapA := map[string]string{"EndpointId": endpoint.Id}
232 settingsJson, err := json.Marshal(mapA)
233 if err != nil {
234 t.Fatal(err)
235 }
236 requestMessage := &ModifyNamespaceSettingRequest{
237 ResourceType: NamespaceResourceTypeEndpoint,
238 RequestType: RequestTypeAdd,
239 Settings: settingsJson,
240 }
241
242 err = ModifyNamespaceSettings(namespace.Id, requestMessage)
243 if err != nil {
244 t.Fatal(err)
245 }
246 foundEndpoints, err := GetNamespaceEndpointIds(namespace.Id)
247 if err != nil {
248 t.Fatal(err)
249 }
250 if len(foundEndpoints) == 0 {
251 t.Fatal("No Endpoint found")
252 }
253 err = RemoveNamespaceEndpoint(namespace.Id, endpoint.Id)
254 if err != nil {
255 t.Fatal(err)
256 }
257
258 err = namespace.Delete()
259 if err != nil {
260 t.Fatal(err)
261 }
262 err = endpoint.Delete()
263 if err != nil {
264 t.Fatal(err)
265 }
266 err = network.Delete()
267 if err != nil {
268 t.Fatal(err)
269 }
270 }
271
272
273
274 func TestSyncNamespaceHostDefault(t *testing.T) {
275 namespace := &HostComputeNamespace{
276 Type: NamespaceTypeHostDefault,
277 NamespaceId: 5,
278 SchemaVersion: SchemaVersion{
279 Major: 2,
280 Minor: 0,
281 },
282 }
283
284 hnsNamespace, err := namespace.Create()
285 if err != nil {
286 t.Fatal(err)
287 }
288
289
290 err = hnsNamespace.Sync()
291 if err != nil {
292 t.Fatal(err)
293 }
294
295 err = hnsNamespace.Delete()
296 if err != nil {
297 t.Fatal(err)
298 }
299 }
300
301 func TestSyncNamespaceHost(t *testing.T) {
302 namespace := &HostComputeNamespace{
303 Type: NamespaceTypeHost,
304 NamespaceId: 5,
305 SchemaVersion: SchemaVersion{
306 Major: 2,
307 Minor: 0,
308 },
309 }
310
311 hnsNamespace, err := namespace.Create()
312 if err != nil {
313 t.Fatal(err)
314 }
315
316
317 err = hnsNamespace.Sync()
318 if err != nil {
319 t.Fatal(err)
320 }
321
322 err = hnsNamespace.Delete()
323 if err != nil {
324 t.Fatal(err)
325 }
326 }
327
328 func TestSyncNamespaceGuestNoReg(t *testing.T) {
329 namespace := &HostComputeNamespace{
330 Type: NamespaceTypeGuest,
331 NamespaceId: 5,
332 SchemaVersion: SchemaVersion{
333 Major: 2,
334 Minor: 0,
335 },
336 }
337
338 hnsNamespace, err := namespace.Create()
339 if err != nil {
340 t.Fatal(err)
341 }
342
343
344 err = hnsNamespace.Sync()
345 if err != nil {
346 t.Fatal(err)
347 }
348
349 err = hnsNamespace.Delete()
350 if err != nil {
351 t.Fatal(err)
352 }
353 }
354
355 func TestSyncNamespaceGuestDefaultNoReg(t *testing.T) {
356 namespace := &HostComputeNamespace{
357 Type: NamespaceTypeGuestDefault,
358 NamespaceId: 5,
359 SchemaVersion: SchemaVersion{
360 Major: 2,
361 Minor: 0,
362 },
363 }
364
365 hnsNamespace, err := namespace.Create()
366 if err != nil {
367 t.Fatal(err)
368 }
369
370
371 err = hnsNamespace.Sync()
372 if err != nil {
373 t.Fatal(err)
374 }
375
376 err = hnsNamespace.Delete()
377 if err != nil {
378 t.Fatal(err)
379 }
380 }
381
382 func TestSyncNamespaceGuest(t *testing.T) {
383 namespace := &HostComputeNamespace{
384 Type: NamespaceTypeGuest,
385 NamespaceId: 5,
386 SchemaVersion: SchemaVersion{
387 Major: 2,
388 Minor: 0,
389 },
390 }
391
392 hnsNamespace, err := namespace.Create()
393
394 if err != nil {
395 t.Fatal(err)
396 }
397
398
399 pnc := cni.NewPersistedNamespaceConfig(t.Name(), "test-container", newGUID(t))
400 err = pnc.Store()
401 if err != nil {
402 _ = pnc.Remove()
403 t.Fatal(err)
404 }
405
406
407
408 err = hnsNamespace.Sync()
409 if err != nil {
410 t.Fatal(err)
411 }
412
413 err = pnc.Remove()
414 if err != nil {
415 t.Fatal(err)
416 }
417 err = hnsNamespace.Delete()
418 if err != nil {
419 t.Fatal(err)
420 }
421 }
422
423 func TestSyncNamespaceGuestDefault(t *testing.T) {
424 namespace := &HostComputeNamespace{
425 Type: NamespaceTypeGuestDefault,
426 NamespaceId: 5,
427 SchemaVersion: SchemaVersion{
428 Major: 2,
429 Minor: 0,
430 },
431 }
432
433 hnsNamespace, err := namespace.Create()
434 if err != nil {
435 t.Fatal(err)
436 }
437
438
439 pnc := cni.NewPersistedNamespaceConfig(t.Name(), "test-container", newGUID(t))
440 err = pnc.Store()
441 if err != nil {
442 _ = pnc.Remove()
443 t.Fatal(err)
444 }
445
446
447
448 err = hnsNamespace.Sync()
449 if err != nil {
450 t.Fatal(err)
451 }
452
453 err = pnc.Remove()
454 if err != nil {
455 t.Fatal(err)
456 }
457 err = hnsNamespace.Delete()
458 if err != nil {
459 t.Fatal(err)
460 }
461 }
462
View as plain text