1
2
3 package main
4
5 import (
6 "context"
7 "testing"
8
9 "github.com/Microsoft/hcsshim/internal/computeagent"
10 computeagentMock "github.com/Microsoft/hcsshim/internal/computeagent/mock"
11 ncproxynetworking "github.com/Microsoft/hcsshim/internal/ncproxy/networking"
12 ncproxygrpc "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1"
13 "github.com/golang/mock/gomock"
14 )
15
16 func TestAddNIC_NCProxy(t *testing.T) {
17 ctx := context.Background()
18
19 var (
20 containerID = t.Name() + "-containerID"
21 testNICID = t.Name() + "-nicID"
22 testEndpointName = t.Name() + "-endpoint"
23 )
24
25 networkingStore, closer, err := createTestNetworkingStore()
26 if err != nil {
27 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
28 }
29 defer closer()
30
31
32 agentCache := newComputeAgentCache()
33 gService := newGRPCService(agentCache, networkingStore)
34
35
36 computeAgentCtrl := gomock.NewController(t)
37 defer computeAgentCtrl.Finish()
38 mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
39 mockedAgentClient := &computeAgentClient{nil, mockedService}
40
41
42 if err := agentCache.put(containerID, mockedAgentClient); err != nil {
43 t.Fatal(err)
44 }
45
46
47 mockedService.EXPECT().AddNIC(gomock.Any(), gomock.Any()).Return(&computeagent.AddNICInternalResponse{}, nil).AnyTimes()
48 mockedService.EXPECT().AssignPCI(gomock.Any(), gomock.Any()).Return(&computeagent.AssignPCIInternalResponse{}, nil).AnyTimes()
49
50
51 endpoint := &ncproxynetworking.Endpoint{
52 EndpointName: testEndpointName,
53 Settings: &ncproxynetworking.EndpointSettings{
54 DeviceDetails: &ncproxynetworking.DeviceDetails{
55 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
56 },
57 },
58 }
59 if err := gService.ncpNetworkingStore.CreatEndpoint(ctx, endpoint); err != nil {
60 t.Fatal(err)
61 }
62
63 type config struct {
64 name string
65 containerID string
66 nicID string
67 endpointName string
68 errorExpected bool
69 }
70 tests := []config{
71 {
72 name: "AddNIC returns no error",
73 containerID: containerID,
74 nicID: testNICID,
75 endpointName: testEndpointName,
76 errorExpected: false,
77 },
78 {
79 name: "AddNIC returns error with blank container ID",
80 containerID: "",
81 nicID: testNICID,
82 endpointName: testEndpointName,
83 errorExpected: true,
84 },
85 {
86 name: "AddNIC returns error with blank nic ID",
87 containerID: containerID,
88 nicID: "",
89 endpointName: testEndpointName,
90 errorExpected: true,
91 },
92 {
93 name: "AddNIC returns error with blank endpoint name",
94 containerID: containerID,
95 nicID: testNICID,
96 endpointName: "",
97 errorExpected: true,
98 },
99 }
100
101 for _, test := range tests {
102 t.Run(test.name, func(subtest *testing.T) {
103 req := &ncproxygrpc.AddNICRequest{
104 ContainerID: test.containerID,
105 NicID: test.nicID,
106 EndpointName: test.endpointName,
107 }
108
109 _, err := gService.AddNIC(ctx, req)
110 if test.errorExpected && err == nil {
111 subtest.Fatalf("expected AddNIC to return an error")
112 }
113 if !test.errorExpected && err != nil {
114 subtest.Fatalf("expected AddNIC to return no error, instead got %v", err)
115 }
116 })
117 }
118 }
119
120 func TestDeleteNIC_NCProxy(t *testing.T) {
121 ctx := context.Background()
122
123 var (
124 containerID = t.Name() + "-containerID"
125 testNICID = t.Name() + "-nicID"
126 testEndpointName = t.Name() + "-endpoint"
127 )
128
129 networkingStore, closer, err := createTestNetworkingStore()
130 if err != nil {
131 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
132 }
133 defer closer()
134
135
136 agentCache := newComputeAgentCache()
137 gService := newGRPCService(agentCache, networkingStore)
138
139
140 computeAgentCtrl := gomock.NewController(t)
141 defer computeAgentCtrl.Finish()
142 mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
143 mockedAgentClient := &computeAgentClient{nil, mockedService}
144
145
146 if err := agentCache.put(containerID, mockedAgentClient); err != nil {
147 t.Fatal(err)
148 }
149
150
151 mockedService.EXPECT().DeleteNIC(gomock.Any(), gomock.Any()).Return(&computeagent.DeleteNICInternalResponse{}, nil).AnyTimes()
152
153
154 endpoint := &ncproxynetworking.Endpoint{
155 EndpointName: testEndpointName,
156 Settings: &ncproxynetworking.EndpointSettings{
157 DeviceDetails: &ncproxynetworking.DeviceDetails{
158 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
159 },
160 },
161 }
162 _ = gService.ncpNetworkingStore.CreatEndpoint(ctx, endpoint)
163
164 type config struct {
165 name string
166 containerID string
167 nicID string
168 endpointName string
169 errorExpected bool
170 }
171 tests := []config{
172 {
173 name: "DeleteNIC returns no error",
174 containerID: containerID,
175 nicID: testNICID,
176 endpointName: testEndpointName,
177 errorExpected: false,
178 },
179 {
180 name: "DeleteNIC returns error with blank container ID",
181 containerID: "",
182 nicID: testNICID,
183 endpointName: testEndpointName,
184 errorExpected: true,
185 },
186 {
187 name: "DeleteNIC returns error with blank nic ID",
188 containerID: containerID,
189 nicID: "",
190 endpointName: testEndpointName,
191 errorExpected: true,
192 },
193 {
194 name: "DeleteNIC returns error with blank endpoint name",
195 containerID: containerID,
196 nicID: testNICID,
197 endpointName: "",
198 errorExpected: true,
199 },
200 }
201
202 for _, test := range tests {
203 t.Run(test.name, func(subtest *testing.T) {
204 req := &ncproxygrpc.DeleteNICRequest{
205 ContainerID: test.containerID,
206 NicID: test.nicID,
207 EndpointName: test.endpointName,
208 }
209
210 _, err := gService.DeleteNIC(ctx, req)
211 if test.errorExpected && err == nil {
212 subtest.Fatalf("expected DeleteNIC to return an error")
213 }
214 if !test.errorExpected && err != nil {
215 subtest.Fatalf("expected DeleteNIC to return no error, instead got %v", err)
216 }
217 })
218 }
219 }
220
221 func TestModifyNIC_NCProxy_Returns_Error(t *testing.T) {
222 ctx := context.Background()
223
224 networkingStore, closer, err := createTestNetworkingStore()
225 if err != nil {
226 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
227 }
228 defer closer()
229
230
231 agentCache := newComputeAgentCache()
232 gService := newGRPCService(agentCache, networkingStore)
233
234 var (
235 containerID = t.Name() + "-containerID"
236 testNICID = t.Name() + "-nicID"
237 testEndpointName = t.Name() + "-endpoint"
238 )
239
240
241 computeAgentCtrl := gomock.NewController(t)
242 defer computeAgentCtrl.Finish()
243 mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
244 mockedAgentClient := &computeAgentClient{nil, mockedService}
245
246
247 if err := agentCache.put(containerID, mockedAgentClient); err != nil {
248 t.Fatal(err)
249 }
250
251
252 mockedService.EXPECT().ModifyNIC(gomock.Any(), gomock.Any()).Return(&computeagent.ModifyNICInternalResponse{}, nil).AnyTimes()
253
254
255 endpoint := &ncproxynetworking.Endpoint{
256 EndpointName: testEndpointName,
257 Settings: &ncproxynetworking.EndpointSettings{
258 DeviceDetails: &ncproxynetworking.DeviceDetails{
259 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
260 },
261 },
262 }
263 _ = gService.ncpNetworkingStore.CreatEndpoint(ctx, endpoint)
264
265
266 settings := &ncproxygrpc.NCProxyEndpointSettings{}
267 req := &ncproxygrpc.ModifyNICRequest{
268 ContainerID: containerID,
269 NicID: testNICID,
270 EndpointName: testEndpointName,
271 EndpointSettings: &ncproxygrpc.EndpointSettings{
272 Settings: &ncproxygrpc.EndpointSettings_NcproxyEndpoint{
273 NcproxyEndpoint: settings,
274 },
275 },
276 }
277
278 _, err = gService.ModifyNIC(ctx, req)
279 if err == nil {
280 t.Fatal("expected ModifyNIC to return an error for a ncproxy networking endpoint")
281 }
282 }
283
284 func TestCreateNetwork_NCProxy(t *testing.T) {
285 ctx := context.Background()
286
287 networkingStore, closer, err := createTestNetworkingStore()
288 if err != nil {
289 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
290 }
291 defer closer()
292
293
294 agentCache := newComputeAgentCache()
295 gService := newGRPCService(agentCache, networkingStore)
296
297 containerID := t.Name() + "-test-networkf"
298
299
300 computeAgentCtrl := gomock.NewController(t)
301 defer computeAgentCtrl.Finish()
302 mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
303 mockedAgentClient := &computeAgentClient{nil, mockedService}
304
305
306 if err := agentCache.put(containerID, mockedAgentClient); err != nil {
307 t.Fatal(err)
308 }
309
310
311 mockedService.EXPECT().AssignPCI(gomock.Any(), gomock.Any()).Return(&computeagent.AssignPCIInternalResponse{}, nil).AnyTimes()
312
313 type config struct {
314 name string
315 networkName string
316 errorExpected bool
317 }
318 tests := []config{
319 {
320 name: "CreateNetwork returns no error",
321 networkName: t.Name() + "-network",
322 errorExpected: false,
323 },
324 {
325 name: "CreateNetwork returns error with blank network name",
326 networkName: "",
327 errorExpected: true,
328 },
329 }
330
331 for _, test := range tests {
332 t.Run(test.name, func(subtest *testing.T) {
333 network := &ncproxygrpc.NCProxyNetworkSettings{
334 Name: test.networkName,
335 }
336 req := &ncproxygrpc.CreateNetworkRequest{
337 Network: &ncproxygrpc.Network{
338 Settings: &ncproxygrpc.Network_NcproxyNetwork{
339 NcproxyNetwork: network,
340 },
341 },
342 }
343 _, err := gService.CreateNetwork(ctx, req)
344 if test.errorExpected && err == nil {
345 subtest.Fatalf("expected CreateNetwork to return an error")
346 }
347
348 if !test.errorExpected {
349 _, err := gService.ncpNetworkingStore.GetNetworkByName(ctx, test.networkName)
350 if err != nil {
351 subtest.Fatalf("failed to find created network with %v", err)
352 }
353 }
354 })
355 }
356 }
357
358 func TestCreateEndpoint_NCProxy(t *testing.T) {
359 ctx := context.Background()
360
361 networkingStore, closer, err := createTestNetworkingStore()
362 if err != nil {
363 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
364 }
365 defer closer()
366
367
368 agentCache := newComputeAgentCache()
369 gService := newGRPCService(agentCache, networkingStore)
370
371 networkName := t.Name() + "-network"
372 network := &ncproxynetworking.Network{
373 NetworkName: networkName,
374 Settings: &ncproxynetworking.NetworkSettings{},
375 }
376 _ = gService.ncpNetworkingStore.CreateNetwork(ctx, network)
377
378 type config struct {
379 name string
380 networkName string
381 ipaddress string
382 macaddress string
383 errorExpected bool
384 }
385
386 tests := []config{
387 {
388 name: "CreateEndpoint returns no error",
389 networkName: networkName,
390 ipaddress: "192.168.100.4",
391 macaddress: "00-15-5D-52-C0-00",
392 errorExpected: false,
393 },
394 {
395 name: "CreateEndpoint returns error when network name is empty",
396 networkName: "",
397 ipaddress: "192.168.100.4",
398 macaddress: "00-15-5D-52-C0-00",
399 errorExpected: true,
400 },
401 {
402 name: "CreateEndpoint returns error when ip address is empty",
403 networkName: networkName,
404 ipaddress: "",
405 macaddress: "00-15-5D-52-C0-00",
406 errorExpected: true,
407 },
408 {
409 name: "CreateEndpoint returns error when mac address is empty",
410 networkName: networkName,
411 ipaddress: "192.168.100.4",
412 macaddress: "",
413 errorExpected: true,
414 },
415 }
416
417 for _, test := range tests {
418 t.Run(test.name, func(subtest *testing.T) {
419 endpointName := subtest.Name() + "-endpoint-"
420 endpoint := &ncproxygrpc.NCProxyEndpointSettings{
421 Name: endpointName,
422 Macaddress: test.macaddress,
423 Ipaddress: test.ipaddress,
424 IpaddressPrefixlength: 24,
425 NetworkName: test.networkName,
426 DeviceDetails: &ncproxygrpc.NCProxyEndpointSettings_PciDeviceDetails{
427 PciDeviceDetails: &ncproxygrpc.PCIDeviceDetails{},
428 },
429 }
430 req := &ncproxygrpc.CreateEndpointRequest{
431 EndpointSettings: &ncproxygrpc.EndpointSettings{
432 Settings: &ncproxygrpc.EndpointSettings_NcproxyEndpoint{
433 NcproxyEndpoint: endpoint,
434 },
435 },
436 }
437
438 _, err := gService.CreateEndpoint(ctx, req)
439 if test.errorExpected && err == nil {
440 subtest.Fatalf("expected CreateEndpoint to return an error")
441 }
442 if !test.errorExpected {
443 if err != nil {
444 subtest.Fatalf("expected to get no error, instead got %v", err)
445 }
446 _, err := gService.ncpNetworkingStore.GetEndpointByName(ctx, endpointName)
447 if err != nil {
448 subtest.Fatalf("failed to find created endpoint with %v", err)
449 }
450 }
451 })
452 }
453 }
454
455 func TestAddEndpoint_NoError_NCProxy(t *testing.T) {
456 ctx := context.Background()
457
458 networkingStore, closer, err := createTestNetworkingStore()
459 if err != nil {
460 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
461 }
462 defer closer()
463
464
465 agentCache := newComputeAgentCache()
466 gService := newGRPCService(agentCache, networkingStore)
467
468 namespace := t.Name() + "-namespace"
469 endpointName := t.Name() + "-endpoint"
470 endpoint := &ncproxynetworking.Endpoint{
471 EndpointName: endpointName,
472 Settings: &ncproxynetworking.EndpointSettings{
473 DeviceDetails: &ncproxynetworking.DeviceDetails{
474 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
475 },
476 },
477 }
478
479 if err := networkingStore.CreatEndpoint(ctx, endpoint); err != nil {
480 t.Fatal(err)
481 }
482
483 req := &ncproxygrpc.AddEndpointRequest{
484 Name: endpointName,
485 NamespaceID: namespace,
486 }
487
488 _, err = gService.AddEndpoint(ctx, req)
489 if err != nil {
490 t.Fatalf("expected AddEndpoint to return no error, instead got %v", err)
491 }
492 updatedEndpt, err := networkingStore.GetEndpointByName(ctx, endpointName)
493 if err != nil {
494 t.Fatalf("expected to find endpoint in the networking store, instead got %v", err)
495 }
496 if updatedEndpt.NamespaceID != namespace {
497 t.Fatalf("expected endpoint have namespace %s, instead got %s", namespace, updatedEndpt.NamespaceID)
498 }
499 }
500
501 func TestAddEndpoint_Error_EmptyEndpointName_NCProxy(t *testing.T) {
502 ctx := context.Background()
503
504 networkingStore, closer, err := createTestNetworkingStore()
505 if err != nil {
506 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
507 }
508 defer closer()
509
510
511 agentCache := newComputeAgentCache()
512 gService := newGRPCService(agentCache, networkingStore)
513
514 req := &ncproxygrpc.AddEndpointRequest{
515 Name: "",
516 NamespaceID: t.Name() + "-namespace",
517 }
518
519 _, err = gService.AddEndpoint(ctx, req)
520 if err == nil {
521 t.Fatal("expected AddEndpoint to return error when endpoint name is empty")
522 }
523 }
524
525 func TestAddEndpoint_Error_NoEndpoint_NCProxy(t *testing.T) {
526 ctx := context.Background()
527
528 networkingStore, closer, err := createTestNetworkingStore()
529 if err != nil {
530 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
531 }
532 defer closer()
533
534
535 agentCache := newComputeAgentCache()
536 gService := newGRPCService(agentCache, networkingStore)
537
538 req := &ncproxygrpc.AddEndpointRequest{
539 Name: t.Name() + "-endpoint",
540 NamespaceID: t.Name() + "-namespace",
541 }
542
543 _, err = gService.AddEndpoint(ctx, req)
544 if err == nil {
545 t.Fatal("expected AddEndpoint to return error when endpoint name is empty")
546 }
547 }
548
549 func TestAddEndpoint_Error_EmptyNamespaceID_NCProxy(t *testing.T) {
550 ctx := context.Background()
551
552 networkingStore, closer, err := createTestNetworkingStore()
553 if err != nil {
554 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
555 }
556 defer closer()
557
558
559 agentCache := newComputeAgentCache()
560 gService := newGRPCService(agentCache, networkingStore)
561
562 endpointName := t.Name() + "-test-endpoint"
563 endpoint := &ncproxynetworking.Endpoint{
564 EndpointName: endpointName,
565 Settings: &ncproxynetworking.EndpointSettings{
566 DeviceDetails: &ncproxynetworking.DeviceDetails{
567 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
568 },
569 },
570 }
571
572 if err := networkingStore.CreatEndpoint(ctx, endpoint); err != nil {
573 t.Fatal(err)
574 }
575
576 req := &ncproxygrpc.AddEndpointRequest{
577 Name: endpointName,
578 NamespaceID: "",
579 }
580
581 _, err = gService.AddEndpoint(ctx, req)
582 if err == nil {
583 t.Fatal("expected AddEndpoint to return error when namespace ID is empty")
584 }
585 }
586
587 func TestDeleteEndpoint_NoError_NCProxy(t *testing.T) {
588 ctx := context.Background()
589
590 networkingStore, closer, err := createTestNetworkingStore()
591 if err != nil {
592 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
593 }
594 defer closer()
595
596
597 agentCache := newComputeAgentCache()
598 gService := newGRPCService(agentCache, networkingStore)
599
600 endpointName := t.Name() + "-test-endpoint"
601 endpoint := &ncproxynetworking.Endpoint{
602 EndpointName: endpointName,
603 Settings: &ncproxynetworking.EndpointSettings{
604 DeviceDetails: &ncproxynetworking.DeviceDetails{
605 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
606 },
607 },
608 }
609
610 if err := networkingStore.CreatEndpoint(ctx, endpoint); err != nil {
611 t.Fatal(err)
612 }
613
614 req := &ncproxygrpc.DeleteEndpointRequest{
615 Name: endpointName,
616 }
617 _, err = gService.DeleteEndpoint(ctx, req)
618 if err != nil {
619 t.Fatalf("expected DeleteEndpoint to return no error, instead got %v", err)
620 }
621 actualEndpoint, err := networkingStore.GetEndpointByName(ctx, endpointName)
622 if err == nil {
623 t.Fatalf("expected endpoint to be deleted, instead found %v", actualEndpoint)
624 }
625 }
626
627 func TestDeleteEndpoint_Error_NoEndpoint_NCProxy(t *testing.T) {
628 ctx := context.Background()
629
630 networkingStore, closer, err := createTestNetworkingStore()
631 if err != nil {
632 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
633 }
634 defer closer()
635
636
637 agentCache := newComputeAgentCache()
638 gService := newGRPCService(agentCache, networkingStore)
639
640 req := &ncproxygrpc.DeleteEndpointRequest{
641 Name: t.Name() + "-endpoint",
642 }
643 _, err = gService.DeleteEndpoint(ctx, req)
644 if err == nil {
645 t.Fatalf("expected to return an error on deleting nonexistent endpoint")
646 }
647 }
648
649 func TestDeleteEndpoint_Error_EmptyEndpoint_Name_NCProxy(t *testing.T) {
650 ctx := context.Background()
651
652 networkingStore, closer, err := createTestNetworkingStore()
653 if err != nil {
654 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
655 }
656 defer closer()
657
658
659 agentCache := newComputeAgentCache()
660 gService := newGRPCService(agentCache, networkingStore)
661
662 endpointName := ""
663 req := &ncproxygrpc.DeleteEndpointRequest{
664 Name: endpointName,
665 }
666
667 _, err = gService.DeleteEndpoint(ctx, req)
668 if err == nil {
669 t.Fatalf("expected to return an error when endpoint name is empty")
670 }
671 }
672
673 func TestDeleteNetwork_NoError_NCProxy(t *testing.T) {
674 ctx := context.Background()
675
676 networkingStore, closer, err := createTestNetworkingStore()
677 if err != nil {
678 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
679 }
680 defer closer()
681
682
683 agentCache := newComputeAgentCache()
684 gService := newGRPCService(agentCache, networkingStore)
685
686 networkName := t.Name() + "-network"
687 network := &ncproxynetworking.Network{
688 NetworkName: networkName,
689 Settings: &ncproxynetworking.NetworkSettings{},
690 }
691 if err := networkingStore.CreateNetwork(ctx, network); err != nil {
692 t.Fatal(err)
693 }
694
695 req := &ncproxygrpc.DeleteNetworkRequest{
696 Name: networkName,
697 }
698 _, err = gService.DeleteNetwork(ctx, req)
699 if err != nil {
700 t.Fatalf("expected no error, instead got %v", err)
701 }
702 actualNetwork, err := networkingStore.GetNetworkByName(ctx, networkName)
703 if err == nil {
704 t.Fatalf("expected network to be deleted, instead found %v", actualNetwork)
705 }
706 }
707
708 func TestDeleteNetwork_Error_NoNetwork_NCProxy(t *testing.T) {
709 ctx := context.Background()
710
711 networkingStore, closer, err := createTestNetworkingStore()
712 if err != nil {
713 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
714 }
715 defer closer()
716
717
718 agentCache := newComputeAgentCache()
719 gService := newGRPCService(agentCache, networkingStore)
720
721 fakeNetworkName := t.Name() + "-network"
722
723 req := &ncproxygrpc.DeleteNetworkRequest{
724 Name: fakeNetworkName,
725 }
726 _, err = gService.DeleteNetwork(ctx, req)
727 if err == nil {
728 t.Fatal("expected to get an error when attempting to delete nonexistent network")
729 }
730 }
731
732 func TestDeleteNetwork_Error_EmptyNetworkName_NCProxy(t *testing.T) {
733 ctx := context.Background()
734
735 networkingStore, closer, err := createTestNetworkingStore()
736 if err != nil {
737 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
738 }
739 defer closer()
740
741
742 agentCache := newComputeAgentCache()
743 gService := newGRPCService(agentCache, networkingStore)
744
745 req := &ncproxygrpc.DeleteNetworkRequest{
746 Name: "",
747 }
748 _, err = gService.DeleteNetwork(ctx, req)
749 if err == nil {
750 t.Fatal("expected to get an error when attempting to delete nonexistent network")
751 }
752 }
753
754 func TestGetEndpoint_NoError_NCProxy(t *testing.T) {
755 ctx := context.Background()
756
757 networkingStore, closer, err := createTestNetworkingStore()
758 if err != nil {
759 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
760 }
761 defer closer()
762
763
764 agentCache := newComputeAgentCache()
765 gService := newGRPCService(agentCache, networkingStore)
766
767 endpointName := t.Name() + "-endpoint"
768 endpoint := &ncproxynetworking.Endpoint{
769 EndpointName: endpointName,
770 Settings: &ncproxynetworking.EndpointSettings{
771 DeviceDetails: &ncproxynetworking.DeviceDetails{
772 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
773 },
774 },
775 }
776 if err := networkingStore.CreatEndpoint(ctx, endpoint); err != nil {
777 t.Fatal(err)
778 }
779 req := &ncproxygrpc.GetEndpointRequest{
780 Name: endpointName,
781 }
782 if _, err := gService.GetEndpoint(ctx, req); err != nil {
783 t.Fatalf("expected to get no error, instead got %v", err)
784 }
785 }
786
787 func TestGetEndpoint_Error_NoEndpoint_NCProxy(t *testing.T) {
788 ctx := context.Background()
789
790 networkingStore, closer, err := createTestNetworkingStore()
791 if err != nil {
792 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
793 }
794 defer closer()
795
796
797 agentCache := newComputeAgentCache()
798 gService := newGRPCService(agentCache, networkingStore)
799
800 endpointName := t.Name() + "-endpoint"
801 req := &ncproxygrpc.GetEndpointRequest{
802 Name: endpointName,
803 }
804
805 if _, err := gService.GetEndpoint(ctx, req); err == nil {
806 t.Fatal("expected to get an error trying to get a nonexistent endpoint")
807 }
808 }
809
810 func TestGetEndpoint_Error_EmptyEndpointName_NCProxy(t *testing.T) {
811 ctx := context.Background()
812
813 networkingStore, closer, err := createTestNetworkingStore()
814 if err != nil {
815 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
816 }
817 defer closer()
818
819
820 agentCache := newComputeAgentCache()
821 gService := newGRPCService(agentCache, networkingStore)
822
823 req := &ncproxygrpc.GetEndpointRequest{
824 Name: "",
825 }
826
827 if _, err := gService.GetEndpoint(ctx, req); err == nil {
828 t.Fatal("expected to get an error with empty endpoint name")
829 }
830 }
831
832 func TestGetEndpoints_NoError_NCProxy(t *testing.T) {
833 ctx := context.Background()
834
835 networkingStore, closer, err := createTestNetworkingStore()
836 if err != nil {
837 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
838 }
839 defer closer()
840
841
842 agentCache := newComputeAgentCache()
843 gService := newGRPCService(agentCache, networkingStore)
844
845 endpointName := t.Name() + "-endpoint"
846 endpoint := &ncproxynetworking.Endpoint{
847 EndpointName: endpointName,
848 Settings: &ncproxynetworking.EndpointSettings{
849 DeviceDetails: &ncproxynetworking.DeviceDetails{
850 PCIDeviceDetails: &ncproxynetworking.PCIDeviceDetails{},
851 },
852 },
853 }
854
855 if err := networkingStore.CreatEndpoint(ctx, endpoint); err != nil {
856 t.Fatal(err)
857 }
858
859 req := &ncproxygrpc.GetEndpointsRequest{}
860 resp, err := gService.GetEndpoints(ctx, req)
861 if err != nil {
862 t.Fatalf("expected to get no error, instead got %v", err)
863 }
864
865 if !endpointExists(endpointName, resp.Endpoints) {
866 t.Fatalf("created endpoint was not found")
867 }
868 }
869
870 func TestGetNetwork_NoError_NCProxy(t *testing.T) {
871 ctx := context.Background()
872
873 networkingStore, closer, err := createTestNetworkingStore()
874 if err != nil {
875 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
876 }
877 defer closer()
878
879
880 agentCache := newComputeAgentCache()
881 gService := newGRPCService(agentCache, networkingStore)
882
883 networkName := t.Name() + "-network"
884 network := &ncproxynetworking.Network{
885 NetworkName: networkName,
886 Settings: &ncproxynetworking.NetworkSettings{},
887 }
888 if err := networkingStore.CreateNetwork(ctx, network); err != nil {
889 t.Fatal(err)
890 }
891 req := &ncproxygrpc.GetNetworkRequest{
892 Name: networkName,
893 }
894 _, err = gService.GetNetwork(ctx, req)
895 if err != nil {
896 t.Fatalf("expected no error, instead got %v", err)
897 }
898 }
899
900 func TestGetNetwork_Error_NoNetwork_NCProxy(t *testing.T) {
901 ctx := context.Background()
902
903 networkingStore, closer, err := createTestNetworkingStore()
904 if err != nil {
905 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
906 }
907 defer closer()
908
909
910 agentCache := newComputeAgentCache()
911 gService := newGRPCService(agentCache, networkingStore)
912
913 fakeNetworkName := t.Name() + "-network"
914 req := &ncproxygrpc.GetNetworkRequest{
915 Name: fakeNetworkName,
916 }
917 _, err = gService.GetNetwork(ctx, req)
918 if err == nil {
919 t.Fatal("expected to get an error when attempting to get nonexistent network")
920 }
921 }
922
923 func TestGetNetwork_Error_EmptyNetworkName_NCProxy(t *testing.T) {
924 ctx := context.Background()
925
926 networkingStore, closer, err := createTestNetworkingStore()
927 if err != nil {
928 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
929 }
930 defer closer()
931
932
933 agentCache := newComputeAgentCache()
934 gService := newGRPCService(agentCache, networkingStore)
935
936
937 req := &ncproxygrpc.GetNetworkRequest{
938 Name: "",
939 }
940 _, err = gService.GetNetwork(ctx, req)
941 if err == nil {
942 t.Fatal("expected to get an error when network name is empty")
943 }
944 }
945
946 func TestGetNetworks_NoError_NCProxy(t *testing.T) {
947 ctx := context.Background()
948
949 networkingStore, closer, err := createTestNetworkingStore()
950 if err != nil {
951 t.Fatalf("failed to create a test ncproxy networking store with %v", err)
952 }
953 defer closer()
954
955
956 agentCache := newComputeAgentCache()
957 gService := newGRPCService(agentCache, networkingStore)
958
959 networkName := t.Name() + "-network"
960 network := &ncproxynetworking.Network{
961 NetworkName: networkName,
962 Settings: &ncproxynetworking.NetworkSettings{
963 Name: networkName,
964 },
965 }
966 if err := networkingStore.CreateNetwork(ctx, network); err != nil {
967 t.Fatal(err)
968 }
969
970 req := &ncproxygrpc.GetNetworksRequest{}
971 resp, err := gService.GetNetworks(ctx, req)
972 if err != nil {
973 t.Fatalf("expected no error, instead got %v", err)
974 }
975 if !networkExists(networkName, resp.Networks) {
976 t.Fatalf("failed to find created network, expected to find network with name %s, found network %v", networkName, resp.Networks)
977 }
978 }
979
View as plain text