Source file src/github.com/Microsoft/hcsshim/cmd/ncproxy/ncproxy_v0_service_test.go

Documentation: github.com/Microsoft/hcsshim/cmd/ncproxy

     1  package main
     2  
     3  import (
     4  	"context"
     5  	"strconv"
     6  	"strings"
     7  	"testing"
     8  
     9  	"github.com/Microsoft/hcsshim/hcn"
    10  	"github.com/Microsoft/hcsshim/internal/computeagent"
    11  	computeagentMock "github.com/Microsoft/hcsshim/internal/computeagent/mock"
    12  	"github.com/Microsoft/hcsshim/osversion"
    13  	ncproxygrpcv0 "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v0"
    14  	"github.com/golang/mock/gomock"
    15  )
    16  
    17  func TestAddNIC_V0_HCN(t *testing.T) {
    18  	ctx := context.Background()
    19  	containerID := t.Name() + "-containerID"
    20  	networkingStore, closer, err := createTestNetworkingStore()
    21  	if err != nil {
    22  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
    23  	}
    24  	defer closer()
    25  
    26  	// setup test ncproxy grpc service
    27  	agentCache := newComputeAgentCache()
    28  	gService := newGRPCService(agentCache, networkingStore)
    29  	v0Service := newV0ServiceWrapper(gService)
    30  
    31  	// create mocked compute agent service
    32  	computeAgentCtrl := gomock.NewController(t)
    33  	defer computeAgentCtrl.Finish()
    34  	mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
    35  	mockedAgentClient := &computeAgentClient{nil, mockedService}
    36  
    37  	// put mocked compute agent in agent cache for test
    38  	if err := agentCache.put(containerID, mockedAgentClient); err != nil {
    39  		t.Fatal(err)
    40  	}
    41  
    42  	// setup expected mocked calls
    43  	mockedService.EXPECT().AddNIC(gomock.Any(), gomock.Any()).Return(&computeagent.AddNICInternalResponse{}, nil).AnyTimes()
    44  
    45  	// test network
    46  	testNetworkName := t.Name() + "-network"
    47  	network, err := createTestIPv4NATNetwork(testNetworkName)
    48  	if err != nil {
    49  		t.Fatalf("failed to create test network with %v", err)
    50  	}
    51  	defer func() {
    52  		_ = network.Delete()
    53  	}()
    54  
    55  	testEndpointName := t.Name() + "-endpoint"
    56  	endpoint, err := createTestEndpoint(testEndpointName, network.Id)
    57  	if err != nil {
    58  		t.Fatalf("failed to create test endpoint with %v", err)
    59  	}
    60  	// defer cleanup in case of error. ignore error from the delete call here
    61  	// since we may have already successfully deleted the endpoint.
    62  	defer func() {
    63  		_ = endpoint.Delete()
    64  	}()
    65  
    66  	testNICID := t.Name() + "-nicID"
    67  	req := &ncproxygrpcv0.AddNICRequest{
    68  		ContainerID:  containerID,
    69  		NicID:        testNICID,
    70  		EndpointName: testEndpointName,
    71  	}
    72  
    73  	_, err = v0Service.AddNIC(ctx, req)
    74  	if err != nil {
    75  		t.Fatalf("expected AddNIC to return no error, instead got %v", err)
    76  	}
    77  }
    78  
    79  func TestAddNIC_V0_HCN_Error_InvalidArgument(t *testing.T) {
    80  	ctx := context.Background()
    81  
    82  	var (
    83  		containerID      = t.Name() + "-containerID"
    84  		testNICID        = t.Name() + "-nicID"
    85  		testEndpointName = t.Name() + "-endpoint"
    86  	)
    87  
    88  	networkingStore, closer, err := createTestNetworkingStore()
    89  	if err != nil {
    90  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
    91  	}
    92  	defer closer()
    93  
    94  	// setup test ncproxy grpc service
    95  	agentCache := newComputeAgentCache()
    96  	gService := newGRPCService(agentCache, networkingStore)
    97  	v0Service := newV0ServiceWrapper(gService)
    98  
    99  	// create mocked compute agent service
   100  	computeAgentCtrl := gomock.NewController(t)
   101  	defer computeAgentCtrl.Finish()
   102  	mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
   103  	mockedAgentClient := &computeAgentClient{nil, mockedService}
   104  
   105  	// put mocked compute agent in agent cache for test
   106  	if err := agentCache.put(containerID, mockedAgentClient); err != nil {
   107  		t.Fatal(err)
   108  	}
   109  
   110  	// setup expected mocked calls
   111  	mockedService.EXPECT().AddNIC(gomock.Any(), gomock.Any()).Return(&computeagent.AddNICInternalResponse{}, nil).AnyTimes()
   112  
   113  	type config struct {
   114  		name         string
   115  		containerID  string
   116  		nicID        string
   117  		endpointName string
   118  	}
   119  	tests := []config{
   120  		{
   121  			name:         "AddNIC returns error with blank container ID",
   122  			containerID:  "",
   123  			nicID:        testNICID,
   124  			endpointName: testEndpointName,
   125  		},
   126  		{
   127  			name:         "AddNIC returns error with blank nic ID",
   128  			containerID:  containerID,
   129  			nicID:        "",
   130  			endpointName: testEndpointName,
   131  		},
   132  		{
   133  			name:         "AddNIC returns error with blank endpoint name",
   134  			containerID:  containerID,
   135  			nicID:        testNICID,
   136  			endpointName: "",
   137  		},
   138  	}
   139  
   140  	for _, test := range tests {
   141  		t.Run(test.name, func(subtest *testing.T) {
   142  			req := &ncproxygrpcv0.AddNICRequest{
   143  				ContainerID:  test.containerID,
   144  				NicID:        test.nicID,
   145  				EndpointName: test.endpointName,
   146  			}
   147  
   148  			_, err := v0Service.AddNIC(ctx, req)
   149  			if err == nil {
   150  				subtest.Fatalf("expected AddNIC to return an error")
   151  			}
   152  		})
   153  	}
   154  }
   155  
   156  func TestDeleteNIC_V0_HCN(t *testing.T) {
   157  	ctx := context.Background()
   158  	containerID := t.Name() + "-containerID"
   159  	networkingStore, closer, err := createTestNetworkingStore()
   160  	if err != nil {
   161  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   162  	}
   163  	defer closer()
   164  
   165  	// setup test ncproxy grpc service
   166  	agentCache := newComputeAgentCache()
   167  	gService := newGRPCService(agentCache, networkingStore)
   168  	v0Service := newV0ServiceWrapper(gService)
   169  
   170  	// create mocked compute agent service
   171  	computeAgentCtrl := gomock.NewController(t)
   172  	defer computeAgentCtrl.Finish()
   173  	mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
   174  	mockedAgentClient := &computeAgentClient{nil, mockedService}
   175  
   176  	// put mocked compute agent in agent cache for test
   177  	if err := agentCache.put(containerID, mockedAgentClient); err != nil {
   178  		t.Fatal(err)
   179  	}
   180  
   181  	// setup expected mocked calls
   182  	mockedService.EXPECT().DeleteNIC(gomock.Any(), gomock.Any()).Return(&computeagent.DeleteNICInternalResponse{}, nil).AnyTimes()
   183  
   184  	// test network
   185  	network, err := createTestIPv4NATNetwork(t.Name() + "network")
   186  	if err != nil {
   187  		t.Fatalf("failed to create test network with %v", err)
   188  	}
   189  	defer func() {
   190  		_ = network.Delete()
   191  	}()
   192  
   193  	testEndpointName := t.Name() + "-endpoint"
   194  	endpoint, err := createTestEndpoint(testEndpointName, network.Id)
   195  	if err != nil {
   196  		t.Fatalf("failed to create test endpoint with %v", err)
   197  	}
   198  	// defer cleanup in case of error. ignore error from the delete call here
   199  	// since we may have already successfully deleted the endpoint.
   200  	defer func() {
   201  		_ = endpoint.Delete()
   202  	}()
   203  
   204  	testNICID := t.Name() + "-nicID"
   205  	req := &ncproxygrpcv0.DeleteNICRequest{
   206  		ContainerID:  containerID,
   207  		NicID:        testNICID,
   208  		EndpointName: testEndpointName,
   209  	}
   210  
   211  	_, err = v0Service.DeleteNIC(ctx, req)
   212  	if err != nil {
   213  		t.Fatalf("expected DeleteNIC to return no error, instead got %v", err)
   214  	}
   215  }
   216  
   217  func TestDeleteNIC_V0_HCN_Error_InvalidArgument(t *testing.T) {
   218  	ctx := context.Background()
   219  
   220  	var (
   221  		containerID      = t.Name() + "-containerID"
   222  		testNICID        = t.Name() + "-nicID"
   223  		testEndpointName = t.Name() + "-endpoint"
   224  	)
   225  
   226  	networkingStore, closer, err := createTestNetworkingStore()
   227  	if err != nil {
   228  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   229  	}
   230  	defer closer()
   231  
   232  	// setup test ncproxy grpc service
   233  	agentCache := newComputeAgentCache()
   234  	gService := newGRPCService(agentCache, networkingStore)
   235  	v0Service := newV0ServiceWrapper(gService)
   236  
   237  	// create mocked compute agent service
   238  	computeAgentCtrl := gomock.NewController(t)
   239  	defer computeAgentCtrl.Finish()
   240  	mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
   241  	mockedAgentClient := &computeAgentClient{nil, mockedService}
   242  
   243  	// put mocked compute agent in agent cache for test
   244  	if err := agentCache.put(containerID, mockedAgentClient); err != nil {
   245  		t.Fatal(err)
   246  	}
   247  
   248  	// setup expected mocked calls
   249  	mockedService.EXPECT().DeleteNIC(gomock.Any(), gomock.Any()).Return(&computeagent.DeleteNICInternalResponse{}, nil).AnyTimes()
   250  
   251  	type config struct {
   252  		name         string
   253  		containerID  string
   254  		nicID        string
   255  		endpointName string
   256  	}
   257  	tests := []config{
   258  		{
   259  			name:         "DeleteNIC returns error with blank container ID",
   260  			containerID:  "",
   261  			nicID:        testNICID,
   262  			endpointName: testEndpointName,
   263  		},
   264  		{
   265  			name:         "DeleteNIC returns error with blank nic ID",
   266  			containerID:  containerID,
   267  			nicID:        "",
   268  			endpointName: testEndpointName,
   269  		},
   270  		{
   271  			name:         "DeleteNIC returns error with blank endpoint name",
   272  			containerID:  containerID,
   273  			nicID:        testNICID,
   274  			endpointName: "",
   275  		},
   276  	}
   277  
   278  	for _, test := range tests {
   279  		t.Run(test.name, func(subtest *testing.T) {
   280  			req := &ncproxygrpcv0.DeleteNICRequest{
   281  				ContainerID:  test.containerID,
   282  				NicID:        test.nicID,
   283  				EndpointName: test.endpointName,
   284  			}
   285  
   286  			_, err := v0Service.DeleteNIC(ctx, req)
   287  			if err == nil {
   288  				subtest.Fatalf("expected DeleteNIC to return an error")
   289  			}
   290  		})
   291  	}
   292  }
   293  
   294  func TestModifyNIC_V0_HCN(t *testing.T) {
   295  	// support for setting IOV policy was added in 21H1
   296  	if osversion.Build() < osversion.V21H1 {
   297  		t.Skip("Requires build +21H1")
   298  	}
   299  	ctx := context.Background()
   300  	containerID := t.Name() + "-containerID"
   301  
   302  	networkingStore, closer, err := createTestNetworkingStore()
   303  	if err != nil {
   304  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   305  	}
   306  	defer closer()
   307  
   308  	// setup test ncproxy grpc service
   309  	agentCache := newComputeAgentCache()
   310  	gService := newGRPCService(agentCache, networkingStore)
   311  	v0Service := newV0ServiceWrapper(gService)
   312  
   313  	// create mock compute agent service
   314  	computeAgentCtrl := gomock.NewController(t)
   315  	defer computeAgentCtrl.Finish()
   316  	mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
   317  	mockedAgentClient := &computeAgentClient{nil, mockedService}
   318  
   319  	// populate agent cache with mocked service for test
   320  	if err := agentCache.put(containerID, mockedAgentClient); err != nil {
   321  		t.Fatal(err)
   322  	}
   323  
   324  	// setup expected mocked calls
   325  	mockedService.EXPECT().ModifyNIC(gomock.Any(), gomock.Any()).Return(&computeagent.ModifyNICInternalResponse{}, nil).AnyTimes()
   326  
   327  	iovOffloadOn := &ncproxygrpcv0.IovEndpointPolicySetting{
   328  		IovOffloadWeight: 100,
   329  	}
   330  
   331  	type config struct {
   332  		name              string
   333  		containerID       string
   334  		iovPolicySettings *ncproxygrpcv0.IovEndpointPolicySetting
   335  		networkCreateFunc func(string) (*hcn.HostComputeNetwork, error)
   336  	}
   337  	tests := []config{
   338  		{
   339  			name:              "ModifyNIC returns no error",
   340  			containerID:       containerID,
   341  			networkCreateFunc: createTestIPv4NATNetwork,
   342  			iovPolicySettings: iovOffloadOn,
   343  		},
   344  		{
   345  			name:              "ModifyNIC dual stack returns no error",
   346  			containerID:       containerID,
   347  			networkCreateFunc: createTestDualStackNATNetwork,
   348  			iovPolicySettings: iovOffloadOn,
   349  		},
   350  		{
   351  			name:              "ModifyNIC returns no error when turning off iov policy",
   352  			containerID:       containerID,
   353  			networkCreateFunc: createTestIPv4NATNetwork,
   354  			iovPolicySettings: &ncproxygrpcv0.IovEndpointPolicySetting{
   355  				IovOffloadWeight: 0,
   356  			},
   357  		},
   358  		{
   359  			name:              "ModifyNIC dual stack returns no error when turning off iov policy",
   360  			containerID:       containerID,
   361  			networkCreateFunc: createTestDualStackNATNetwork,
   362  			iovPolicySettings: &ncproxygrpcv0.IovEndpointPolicySetting{
   363  				IovOffloadWeight: 0,
   364  			},
   365  		},
   366  	}
   367  
   368  	for _, test := range tests {
   369  		t.Run(test.name, func(subtest *testing.T) {
   370  			// create test network
   371  			networkName := subtest.Name() + "-network"
   372  			network, err := test.networkCreateFunc(networkName)
   373  			if err != nil {
   374  				subtest.Fatalf("failed to create test network with %v", err)
   375  			}
   376  			defer func() {
   377  				_ = network.Delete()
   378  			}()
   379  
   380  			// create test endpoint
   381  			endpointName := subtest.Name() + "-endpoint"
   382  			endpoint, err := createTestEndpoint(endpointName, network.Id)
   383  			if err != nil {
   384  				subtest.Fatalf("failed to create test endpoint with %v", err)
   385  			}
   386  			defer func() {
   387  				_ = endpoint.Delete()
   388  			}()
   389  			testNICID := subtest.Name() + "-nicID"
   390  			req := &ncproxygrpcv0.ModifyNICRequest{
   391  				ContainerID:       test.containerID,
   392  				NicID:             testNICID,
   393  				EndpointName:      endpointName,
   394  				IovPolicySettings: test.iovPolicySettings,
   395  			}
   396  
   397  			_, err = v0Service.ModifyNIC(ctx, req)
   398  			if err != nil {
   399  				subtest.Fatalf("expected ModifyNIC to return no error, instead got %v", err)
   400  			}
   401  		})
   402  	}
   403  }
   404  
   405  func TestModifyNIC_V0_HCN_Error_InvalidArgument(t *testing.T) {
   406  	// support for setting IOV policy was added in 21H1
   407  	if osversion.Build() < osversion.V21H1 {
   408  		t.Skip("Requires build +21H1")
   409  	}
   410  	ctx := context.Background()
   411  
   412  	networkingStore, closer, err := createTestNetworkingStore()
   413  	if err != nil {
   414  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   415  	}
   416  	defer closer()
   417  
   418  	// setup test ncproxy grpc service
   419  	agentCache := newComputeAgentCache()
   420  	gService := newGRPCService(agentCache, networkingStore)
   421  	v0Service := newV0ServiceWrapper(gService)
   422  
   423  	var (
   424  		containerID  = t.Name() + "-containerID"
   425  		testNICID    = t.Name() + "-nicID"
   426  		endpointName = t.Name() + "-endpoint"
   427  	)
   428  
   429  	// create mock compute agent service
   430  	computeAgentCtrl := gomock.NewController(t)
   431  	defer computeAgentCtrl.Finish()
   432  	mockedService := computeagentMock.NewMockComputeAgentService(computeAgentCtrl)
   433  	mockedAgentClient := &computeAgentClient{nil, mockedService}
   434  
   435  	// populate agent cache with mocked service for test
   436  	if err := agentCache.put(containerID, mockedAgentClient); err != nil {
   437  		t.Fatal(err)
   438  	}
   439  
   440  	// setup expected mocked calls
   441  	mockedService.EXPECT().ModifyNIC(gomock.Any(), gomock.Any()).Return(&computeagent.ModifyNICInternalResponse{}, nil).AnyTimes()
   442  
   443  	iovOffloadOn := &ncproxygrpcv0.IovEndpointPolicySetting{
   444  		IovOffloadWeight: 100,
   445  	}
   446  
   447  	type config struct {
   448  		name              string
   449  		containerID       string
   450  		nicID             string
   451  		endpointName      string
   452  		iovPolicySettings *ncproxygrpcv0.IovEndpointPolicySetting
   453  	}
   454  	tests := []config{
   455  		{
   456  			name:              "ModifyNIC returns error with blank container ID",
   457  			containerID:       "",
   458  			nicID:             testNICID,
   459  			endpointName:      endpointName,
   460  			iovPolicySettings: iovOffloadOn,
   461  		},
   462  		{
   463  			name:              "ModifyNIC returns error with blank nic ID",
   464  			containerID:       containerID,
   465  			nicID:             "",
   466  			endpointName:      endpointName,
   467  			iovPolicySettings: iovOffloadOn,
   468  		},
   469  		{
   470  			name:              "ModifyNIC returns error with blank endpoint name",
   471  			containerID:       containerID,
   472  			nicID:             testNICID,
   473  			endpointName:      "",
   474  			iovPolicySettings: iovOffloadOn,
   475  		},
   476  		{
   477  			name:              "ModifyNIC returns error with blank iov policy settings",
   478  			containerID:       containerID,
   479  			nicID:             testNICID,
   480  			endpointName:      endpointName,
   481  			iovPolicySettings: nil,
   482  		},
   483  	}
   484  
   485  	for _, test := range tests {
   486  		t.Run(test.name, func(subtest *testing.T) {
   487  			req := &ncproxygrpcv0.ModifyNICRequest{
   488  				ContainerID:       test.containerID,
   489  				NicID:             test.nicID,
   490  				EndpointName:      test.endpointName,
   491  				IovPolicySettings: test.iovPolicySettings,
   492  			}
   493  
   494  			_, err := v0Service.ModifyNIC(ctx, req)
   495  			if err == nil {
   496  				subtest.Fatalf("expected ModifyNIC to return an error")
   497  			}
   498  		})
   499  	}
   500  }
   501  
   502  func TestCreateNetwork_V0_HCN(t *testing.T) {
   503  	ctx := context.Background()
   504  
   505  	networkingStore, closer, err := createTestNetworkingStore()
   506  	if err != nil {
   507  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   508  	}
   509  	defer closer()
   510  
   511  	// setup test ncproxy grpc service
   512  	agentCache := newComputeAgentCache()
   513  	gService := newGRPCService(agentCache, networkingStore)
   514  	v0Service := newV0ServiceWrapper(gService)
   515  
   516  	networkName := t.Name() + "-network"
   517  	ipv4Subnets := getTestIPv4Subnets()
   518  	req := &ncproxygrpcv0.CreateNetworkRequest{
   519  		Name:                  networkName,
   520  		Mode:                  ncproxygrpcv0.CreateNetworkRequest_NAT,
   521  		SubnetIpaddressPrefix: []string{ipv4Subnets[0].IpAddressPrefix},
   522  		DefaultGateway:        ipv4Subnets[0].Routes[0].NextHop,
   523  	}
   524  	_, err = v0Service.CreateNetwork(ctx, req)
   525  	if err != nil {
   526  		t.Fatalf("expected CreateNetwork to return no error, instead got %v", err)
   527  	}
   528  	// validate that the network exists
   529  	network, err := hcn.GetNetworkByName(networkName)
   530  	if err != nil {
   531  		t.Fatalf("failed to find created network with %v", err)
   532  	}
   533  	// cleanup the created network
   534  	if err = network.Delete(); err != nil {
   535  		t.Fatalf("failed to cleanup network %v created by test with %v", networkName, err)
   536  	}
   537  }
   538  
   539  func TestCreateNetwork_V0_HCN_Error_EmptyNetworkName(t *testing.T) {
   540  	ctx := context.Background()
   541  
   542  	networkingStore, closer, err := createTestNetworkingStore()
   543  	if err != nil {
   544  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   545  	}
   546  	defer closer()
   547  
   548  	// setup test ncproxy grpc service
   549  	agentCache := newComputeAgentCache()
   550  	gService := newGRPCService(agentCache, networkingStore)
   551  	v0Service := newV0ServiceWrapper(gService)
   552  
   553  	req := &ncproxygrpcv0.CreateNetworkRequest{
   554  		Name: "",
   555  		Mode: ncproxygrpcv0.CreateNetworkRequest_Transparent,
   556  	}
   557  	_, err = v0Service.CreateNetwork(ctx, req)
   558  	if err == nil {
   559  		t.Fatalf("expected CreateNetwork to return an error")
   560  	}
   561  }
   562  
   563  func TestCreateEndpoint_V0_HCN(t *testing.T) {
   564  	ctx := context.Background()
   565  
   566  	networkingStore, closer, err := createTestNetworkingStore()
   567  	if err != nil {
   568  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   569  	}
   570  	defer closer()
   571  
   572  	// setup test ncproxy grpc service
   573  	agentCache := newComputeAgentCache()
   574  	gService := newGRPCService(agentCache, networkingStore)
   575  	v0Service := newV0ServiceWrapper(gService)
   576  
   577  	// test network
   578  	networkName := t.Name() + "-network"
   579  	network, err := createTestIPv4NATNetwork(networkName)
   580  	if err != nil {
   581  		t.Fatalf("failed to create test network with %v", err)
   582  	}
   583  	defer func() {
   584  		_ = network.Delete()
   585  	}()
   586  
   587  	endpointName := t.Name() + "-endpoint"
   588  	req := &ncproxygrpcv0.CreateEndpointRequest{
   589  		Name:                  endpointName,
   590  		Macaddress:            "00-15-5D-52-C0-00",
   591  		Ipaddress:             "192.168.100.4",
   592  		IpaddressPrefixlength: "24",
   593  		NetworkName:           networkName,
   594  	}
   595  
   596  	_, err = v0Service.CreateEndpoint(ctx, req)
   597  	if err != nil {
   598  		t.Fatalf("expected CreateEndpoint to return no error, instead got %v", err)
   599  	}
   600  	// validate that the endpoint was created
   601  	ep, err := hcn.GetEndpointByName(endpointName)
   602  	if err != nil {
   603  		t.Fatalf("endpoint was not found: %v", err)
   604  	}
   605  	// cleanup endpoint
   606  	if err := ep.Delete(); err != nil {
   607  		t.Fatalf("failed to delete endpoint created for test %v", err)
   608  	}
   609  }
   610  
   611  func TestCreateEndpoint_V0_HCN_Error_InvalidArgument(t *testing.T) {
   612  	ctx := context.Background()
   613  
   614  	networkingStore, closer, err := createTestNetworkingStore()
   615  	if err != nil {
   616  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   617  	}
   618  	defer closer()
   619  
   620  	// setup test ncproxy grpc service
   621  	agentCache := newComputeAgentCache()
   622  	gService := newGRPCService(agentCache, networkingStore)
   623  	v0Service := newV0ServiceWrapper(gService)
   624  
   625  	type config struct {
   626  		name        string
   627  		networkName string
   628  		ipaddress   string
   629  		macaddress  string
   630  	}
   631  	tests := []config{
   632  		{
   633  			name:        "CreateEndpoint returns error when network name is empty",
   634  			networkName: "",
   635  			ipaddress:   "192.168.100.4",
   636  			macaddress:  "00-15-5D-52-C0-00",
   637  		},
   638  		{
   639  			name:        "CreateEndpoint returns error when ip address is empty",
   640  			networkName: "testName",
   641  			ipaddress:   "",
   642  			macaddress:  "00-15-5D-52-C0-00",
   643  		},
   644  		{
   645  			name:        "CreateEndpoint returns error when mac address is empty",
   646  			networkName: "testName",
   647  			ipaddress:   "192.168.100.4",
   648  			macaddress:  "",
   649  		},
   650  	}
   651  
   652  	for i, test := range tests {
   653  		t.Run(test.name, func(subtest *testing.T) {
   654  			endpointName := t.Name() + "-endpoint-" + strconv.Itoa(i)
   655  
   656  			req := &ncproxygrpcv0.CreateEndpointRequest{
   657  				Name:        endpointName,
   658  				Macaddress:  test.macaddress,
   659  				Ipaddress:   test.ipaddress,
   660  				NetworkName: test.networkName,
   661  			}
   662  
   663  			_, err = v0Service.CreateEndpoint(ctx, req)
   664  			if err == nil {
   665  				subtest.Fatalf("expected CreateEndpoint to return an error")
   666  			}
   667  		})
   668  	}
   669  }
   670  
   671  func TestAddEndpoint_V0_NoError(t *testing.T) {
   672  	ctx := context.Background()
   673  
   674  	networkingStore, closer, err := createTestNetworkingStore()
   675  	if err != nil {
   676  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   677  	}
   678  	defer closer()
   679  
   680  	// setup test ncproxy grpc service
   681  	agentCache := newComputeAgentCache()
   682  	gService := newGRPCService(agentCache, networkingStore)
   683  	v0Service := newV0ServiceWrapper(gService)
   684  
   685  	// create test network namespace
   686  	// we need to create a (host) namespace other than the HostDefault to differentiate between
   687  	// the nominal AddEndpoint functionality, and when specifying attach to host
   688  	// the DefaultHost namespace is retrieved below.
   689  	namespace := hcn.NewNamespace(hcn.NamespaceTypeHost)
   690  	namespace, err = namespace.Create()
   691  	if err != nil {
   692  		t.Fatalf("failed to create test namespace with %v", err)
   693  	}
   694  	defer func() {
   695  		_ = namespace.Delete()
   696  	}()
   697  
   698  	// test network
   699  	networkName := t.Name() + "-network"
   700  	network, err := createTestIPv4NATNetwork(networkName)
   701  	if err != nil {
   702  		t.Fatalf("failed to create test network with %v", err)
   703  	}
   704  	defer func() {
   705  		_ = network.Delete()
   706  	}()
   707  
   708  	endpointName := t.Name() + "-endpoint"
   709  	endpoint, err := createTestEndpoint(endpointName, network.Id)
   710  	if err != nil {
   711  		t.Fatalf("failed to create test endpoint with %v", err)
   712  	}
   713  	defer func() {
   714  		_ = endpoint.Delete()
   715  	}()
   716  
   717  	req := &ncproxygrpcv0.AddEndpointRequest{
   718  		Name:        endpointName,
   719  		NamespaceID: namespace.Id,
   720  	}
   721  
   722  	_, err = v0Service.AddEndpoint(ctx, req)
   723  	if err != nil {
   724  		t.Fatalf("expected AddEndpoint to return no error, instead got %v", err)
   725  	}
   726  	// validate endpoint was added to namespace
   727  	endpoints, err := hcn.GetNamespaceEndpointIds(namespace.Id)
   728  	if err != nil {
   729  		t.Fatalf("failed to get the namespace's endpoints with %v", err)
   730  	}
   731  	if !exists(strings.ToUpper(endpoint.Id), endpoints) {
   732  		t.Fatalf("endpoint %v was not added to namespace %v", endpoint.Id, namespace.Id)
   733  	}
   734  }
   735  
   736  func TestAddEndpoint_V0_Error_EmptyEndpointName(t *testing.T) {
   737  	ctx := context.Background()
   738  
   739  	networkingStore, closer, err := createTestNetworkingStore()
   740  	if err != nil {
   741  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   742  	}
   743  	defer closer()
   744  
   745  	// setup test ncproxy grpc service
   746  	agentCache := newComputeAgentCache()
   747  	gService := newGRPCService(agentCache, networkingStore)
   748  	v0Service := newV0ServiceWrapper(gService)
   749  
   750  	// create test network namespace
   751  	namespace := hcn.NewNamespace(hcn.NamespaceTypeHostDefault)
   752  	namespace, err = namespace.Create()
   753  	if err != nil {
   754  		t.Fatalf("failed to create test namespace with %v", err)
   755  	}
   756  	defer func() {
   757  		_ = namespace.Delete()
   758  	}()
   759  
   760  	req := &ncproxygrpcv0.AddEndpointRequest{
   761  		Name:        "",
   762  		NamespaceID: namespace.Id,
   763  	}
   764  
   765  	_, err = v0Service.AddEndpoint(ctx, req)
   766  	if err == nil {
   767  		t.Fatal("expected AddEndpoint to return error when endpoint name is empty")
   768  	}
   769  }
   770  
   771  func TestAddEndpoint_V0_Error_NoEndpoint(t *testing.T) {
   772  	ctx := context.Background()
   773  
   774  	networkingStore, closer, err := createTestNetworkingStore()
   775  	if err != nil {
   776  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   777  	}
   778  	defer closer()
   779  
   780  	// setup test ncproxy grpc service
   781  	agentCache := newComputeAgentCache()
   782  	gService := newGRPCService(agentCache, networkingStore)
   783  	v0Service := newV0ServiceWrapper(gService)
   784  
   785  	// create test network namespace
   786  	namespace := hcn.NewNamespace(hcn.NamespaceTypeHostDefault)
   787  	namespace, err = namespace.Create()
   788  	if err != nil {
   789  		t.Fatalf("failed to create test namespace with %v", err)
   790  	}
   791  	defer func() {
   792  		_ = namespace.Delete()
   793  	}()
   794  
   795  	req := &ncproxygrpcv0.AddEndpointRequest{
   796  		Name:        t.Name() + "-endpoint",
   797  		NamespaceID: namespace.Id,
   798  	}
   799  
   800  	_, err = v0Service.AddEndpoint(ctx, req)
   801  	if err == nil {
   802  		t.Fatal("expected AddEndpoint to return error when endpoint name is empty")
   803  	}
   804  }
   805  
   806  func TestAddEndpoint_V0_Error_EmptyNamespaceID(t *testing.T) {
   807  	ctx := context.Background()
   808  
   809  	networkingStore, closer, err := createTestNetworkingStore()
   810  	if err != nil {
   811  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   812  	}
   813  	defer closer()
   814  
   815  	// setup test ncproxy grpc service
   816  	agentCache := newComputeAgentCache()
   817  	gService := newGRPCService(agentCache, networkingStore)
   818  	v0Service := newV0ServiceWrapper(gService)
   819  
   820  	// test network
   821  	networkName := t.Name() + "-network"
   822  	network, err := createTestIPv4NATNetwork(networkName)
   823  	if err != nil {
   824  		t.Fatalf("failed to create test network with %v", err)
   825  	}
   826  	defer func() {
   827  		_ = network.Delete()
   828  	}()
   829  
   830  	endpointName := t.Name() + "-endpoint"
   831  	endpoint, err := createTestEndpoint(endpointName, network.Id)
   832  	if err != nil {
   833  		t.Fatalf("failed to create test endpoint with %v", err)
   834  	}
   835  	defer func() {
   836  		_ = endpoint.Delete()
   837  	}()
   838  
   839  	req := &ncproxygrpcv0.AddEndpointRequest{
   840  		Name:        endpointName,
   841  		NamespaceID: "",
   842  	}
   843  
   844  	_, err = v0Service.AddEndpoint(ctx, req)
   845  	if err == nil {
   846  		t.Fatal("expected AddEndpoint to return error when namespace ID is empty")
   847  	}
   848  }
   849  
   850  func TestDeleteEndpoint_V0_NoError(t *testing.T) {
   851  	ctx := context.Background()
   852  
   853  	networkingStore, closer, err := createTestNetworkingStore()
   854  	if err != nil {
   855  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   856  	}
   857  	defer closer()
   858  
   859  	// setup test ncproxy grpc service
   860  	agentCache := newComputeAgentCache()
   861  	gService := newGRPCService(agentCache, networkingStore)
   862  	v0Service := newV0ServiceWrapper(gService)
   863  
   864  	// test network
   865  	networkName := t.Name() + "-network"
   866  	network, err := createTestIPv4NATNetwork(networkName)
   867  	if err != nil {
   868  		t.Fatalf("failed to create test network with %v", err)
   869  	}
   870  	// defer cleanup in case of error. ignore error from the delete call here
   871  	// since we may have already successfully deleted the network.
   872  	defer func() {
   873  		_ = network.Delete()
   874  	}()
   875  
   876  	endpointName := t.Name() + "-endpoint"
   877  	endpoint, err := createTestEndpoint(endpointName, network.Id)
   878  	if err != nil {
   879  		t.Fatalf("failed to create test endpoint with %v", err)
   880  	}
   881  	// defer cleanup in case of error. ignore error from the delete call here
   882  	// since we may have already successfully deleted the endpoint.
   883  	defer func() {
   884  		_ = endpoint.Delete()
   885  	}()
   886  
   887  	req := &ncproxygrpcv0.DeleteEndpointRequest{
   888  		Name: endpointName,
   889  	}
   890  	_, err = v0Service.DeleteEndpoint(ctx, req)
   891  	if err != nil {
   892  		t.Fatalf("expected DeleteEndpoint to return no error, instead got %v", err)
   893  	}
   894  	// validate that the endpoint was created
   895  	ep, err := hcn.GetEndpointByName(endpointName)
   896  	if err == nil {
   897  		t.Fatalf("expected endpoint to be deleted, instead found %v", ep)
   898  	}
   899  }
   900  
   901  func TestDeleteEndpoint_V0_Error_NoEndpoint(t *testing.T) {
   902  	ctx := context.Background()
   903  
   904  	networkingStore, closer, err := createTestNetworkingStore()
   905  	if err != nil {
   906  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   907  	}
   908  	defer closer()
   909  
   910  	// setup test ncproxy grpc service
   911  	agentCache := newComputeAgentCache()
   912  	gService := newGRPCService(agentCache, networkingStore)
   913  	v0Service := newV0ServiceWrapper(gService)
   914  
   915  	// test network
   916  	networkName := t.Name() + "-network"
   917  	network, err := createTestIPv4NATNetwork(networkName)
   918  	if err != nil {
   919  		t.Fatalf("failed to create test network with %v", err)
   920  	}
   921  	defer func() {
   922  		_ = network.Delete()
   923  	}()
   924  
   925  	endpointName := t.Name() + "-endpoint"
   926  	req := &ncproxygrpcv0.DeleteEndpointRequest{
   927  		Name: endpointName,
   928  	}
   929  
   930  	_, err = v0Service.DeleteEndpoint(ctx, req)
   931  	if err == nil {
   932  		t.Fatalf("expected to return an error on deleting nonexistent endpoint")
   933  	}
   934  }
   935  
   936  func TestDeleteEndpoint_V0_Error_EmptyEndpoint_Name(t *testing.T) {
   937  	ctx := context.Background()
   938  
   939  	networkingStore, closer, err := createTestNetworkingStore()
   940  	if err != nil {
   941  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   942  	}
   943  	defer closer()
   944  
   945  	// setup test ncproxy grpc service
   946  	agentCache := newComputeAgentCache()
   947  	gService := newGRPCService(agentCache, networkingStore)
   948  	v0Service := newV0ServiceWrapper(gService)
   949  
   950  	endpointName := ""
   951  	req := &ncproxygrpcv0.DeleteEndpointRequest{
   952  		Name: endpointName,
   953  	}
   954  
   955  	_, err = v0Service.DeleteEndpoint(ctx, req)
   956  	if err == nil {
   957  		t.Fatalf("expected to return an error when endpoint name is empty")
   958  	}
   959  }
   960  
   961  func TestDeleteNetwork_V0_NoError(t *testing.T) {
   962  	ctx := context.Background()
   963  
   964  	networkingStore, closer, err := createTestNetworkingStore()
   965  	if err != nil {
   966  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
   967  	}
   968  	defer closer()
   969  
   970  	// setup test ncproxy grpc service
   971  	agentCache := newComputeAgentCache()
   972  	gService := newGRPCService(agentCache, networkingStore)
   973  	v0Service := newV0ServiceWrapper(gService)
   974  
   975  	// test network
   976  	networkName := t.Name() + "-network"
   977  	network, err := createTestIPv4NATNetwork(networkName)
   978  	if err != nil {
   979  		t.Fatalf("failed to create test network with %v", err)
   980  	}
   981  	// defer cleanup in case of error. ignore error from the delete call here
   982  	// since we may have already successfully deleted the network.
   983  	defer func() {
   984  		_ = network.Delete()
   985  	}()
   986  
   987  	req := &ncproxygrpcv0.DeleteNetworkRequest{
   988  		Name: networkName,
   989  	}
   990  	_, err = v0Service.DeleteNetwork(ctx, req)
   991  	if err != nil {
   992  		t.Fatalf("expected no error, instead got %v", err)
   993  	}
   994  }
   995  
   996  func TestDeleteNetwork_V0_Error_NoNetwork(t *testing.T) {
   997  	ctx := context.Background()
   998  
   999  	networkingStore, closer, err := createTestNetworkingStore()
  1000  	if err != nil {
  1001  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1002  	}
  1003  	defer closer()
  1004  
  1005  	// setup test ncproxy grpc service
  1006  	agentCache := newComputeAgentCache()
  1007  	gService := newGRPCService(agentCache, networkingStore)
  1008  	v0Service := newV0ServiceWrapper(gService)
  1009  
  1010  	fakeNetworkName := t.Name() + "-network"
  1011  
  1012  	req := &ncproxygrpcv0.DeleteNetworkRequest{
  1013  		Name: fakeNetworkName,
  1014  	}
  1015  	_, err = v0Service.DeleteNetwork(ctx, req)
  1016  	if err == nil {
  1017  		t.Fatal("expected to get an error when attempting to delete nonexistent network")
  1018  	}
  1019  }
  1020  
  1021  func TestDeleteNetwork_V0_Error_EmptyNetworkName(t *testing.T) {
  1022  	ctx := context.Background()
  1023  
  1024  	networkingStore, closer, err := createTestNetworkingStore()
  1025  	if err != nil {
  1026  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1027  	}
  1028  	defer closer()
  1029  
  1030  	// setup test ncproxy grpc service
  1031  	agentCache := newComputeAgentCache()
  1032  	gService := newGRPCService(agentCache, networkingStore)
  1033  	v0Service := newV0ServiceWrapper(gService)
  1034  
  1035  	req := &ncproxygrpcv0.DeleteNetworkRequest{
  1036  		Name: "",
  1037  	}
  1038  	_, err = v0Service.DeleteNetwork(ctx, req)
  1039  	if err == nil {
  1040  		t.Fatal("expected to get an error when attempting to delete nonexistent network")
  1041  	}
  1042  }
  1043  
  1044  func TestGetEndpoint_V0_NoError(t *testing.T) {
  1045  	ctx := context.Background()
  1046  
  1047  	networkingStore, closer, err := createTestNetworkingStore()
  1048  	if err != nil {
  1049  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1050  	}
  1051  	defer closer()
  1052  
  1053  	// setup test ncproxy grpc service
  1054  	agentCache := newComputeAgentCache()
  1055  	gService := newGRPCService(agentCache, networkingStore)
  1056  	v0Service := newV0ServiceWrapper(gService)
  1057  
  1058  	// test network
  1059  	networkName := t.Name() + "-network"
  1060  	network, err := createTestIPv4NATNetwork(networkName)
  1061  	if err != nil {
  1062  		t.Fatalf("failed to create test network with %v", err)
  1063  	}
  1064  	defer func() {
  1065  		_ = network.Delete()
  1066  	}()
  1067  
  1068  	// test endpoint
  1069  	endpointName := t.Name() + "-endpoint"
  1070  	endpoint, err := createTestEndpoint(endpointName, network.Id)
  1071  	if err != nil {
  1072  		t.Fatalf("failed to create test endpoint with %v", err)
  1073  	}
  1074  	defer func() {
  1075  		_ = endpoint.Delete()
  1076  	}()
  1077  
  1078  	req := &ncproxygrpcv0.GetEndpointRequest{
  1079  		Name: endpointName,
  1080  	}
  1081  
  1082  	if _, err := v0Service.GetEndpoint(ctx, req); err != nil {
  1083  		t.Fatalf("expected to get no error, instead got %v", err)
  1084  	}
  1085  }
  1086  
  1087  func TestGetEndpoint_V0_Error_NoEndpoint(t *testing.T) {
  1088  	ctx := context.Background()
  1089  
  1090  	networkingStore, closer, err := createTestNetworkingStore()
  1091  	if err != nil {
  1092  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1093  	}
  1094  	defer closer()
  1095  
  1096  	// setup test ncproxy grpc service
  1097  	agentCache := newComputeAgentCache()
  1098  	gService := newGRPCService(agentCache, networkingStore)
  1099  	v0Service := newV0ServiceWrapper(gService)
  1100  
  1101  	endpointName := t.Name() + "-endpoint"
  1102  	req := &ncproxygrpcv0.GetEndpointRequest{
  1103  		Name: endpointName,
  1104  	}
  1105  
  1106  	if _, err := v0Service.GetEndpoint(ctx, req); err == nil {
  1107  		t.Fatal("expected to get an error trying to get a nonexistent endpoint")
  1108  	}
  1109  }
  1110  
  1111  func TestGetEndpoint_V0_Error_EmptyEndpointName(t *testing.T) {
  1112  	ctx := context.Background()
  1113  
  1114  	networkingStore, closer, err := createTestNetworkingStore()
  1115  	if err != nil {
  1116  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1117  	}
  1118  	defer closer()
  1119  
  1120  	// setup test ncproxy grpc service
  1121  	agentCache := newComputeAgentCache()
  1122  	gService := newGRPCService(agentCache, networkingStore)
  1123  	v0Service := newV0ServiceWrapper(gService)
  1124  
  1125  	req := &ncproxygrpcv0.GetEndpointRequest{
  1126  		Name: "",
  1127  	}
  1128  
  1129  	if _, err := v0Service.GetEndpoint(ctx, req); err == nil {
  1130  		t.Fatal("expected to get an error with empty endpoint name")
  1131  	}
  1132  }
  1133  
  1134  func TestGetEndpoints_V0_NoError(t *testing.T) {
  1135  	ctx := context.Background()
  1136  
  1137  	networkingStore, closer, err := createTestNetworkingStore()
  1138  	if err != nil {
  1139  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1140  	}
  1141  	defer closer()
  1142  
  1143  	// setup test ncproxy grpc service
  1144  	agentCache := newComputeAgentCache()
  1145  	gService := newGRPCService(agentCache, networkingStore)
  1146  	v0Service := newV0ServiceWrapper(gService)
  1147  
  1148  	// test network
  1149  	networkName := t.Name() + "-network"
  1150  	network, err := createTestIPv4NATNetwork(networkName)
  1151  	if err != nil {
  1152  		t.Fatalf("failed to create test network with %v", err)
  1153  	}
  1154  	defer func() {
  1155  		_ = network.Delete()
  1156  	}()
  1157  
  1158  	// test endpoint
  1159  	endpointName := t.Name() + "-endpoint"
  1160  	endpoint, err := createTestEndpoint(endpointName, network.Id)
  1161  	if err != nil {
  1162  		t.Fatalf("failed to create test endpoint with %v", err)
  1163  	}
  1164  	defer func() {
  1165  		_ = endpoint.Delete()
  1166  	}()
  1167  
  1168  	req := &ncproxygrpcv0.GetEndpointsRequest{}
  1169  	resp, err := v0Service.GetEndpoints(ctx, req)
  1170  	if err != nil {
  1171  		t.Fatalf("expected to get no error, instead got %v", err)
  1172  	}
  1173  
  1174  	if !v0EndpointExists(endpointName, resp.Endpoints) {
  1175  		t.Fatalf("created endpoint was not found")
  1176  	}
  1177  }
  1178  
  1179  func TestGetNetwork_V0_NoError(t *testing.T) {
  1180  	ctx := context.Background()
  1181  
  1182  	networkingStore, closer, err := createTestNetworkingStore()
  1183  	if err != nil {
  1184  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1185  	}
  1186  	defer closer()
  1187  
  1188  	// setup test ncproxy grpc service
  1189  	agentCache := newComputeAgentCache()
  1190  	gService := newGRPCService(agentCache, networkingStore)
  1191  	v0Service := newV0ServiceWrapper(gService)
  1192  
  1193  	// create the test network
  1194  	networkName := t.Name() + "-network"
  1195  	network, err := createTestIPv4NATNetwork(networkName)
  1196  	if err != nil {
  1197  		t.Fatalf("failed to create test network with %v", err)
  1198  	}
  1199  	// defer cleanup in case of error. ignore error from the delete call here
  1200  	// since we may have already successfully deleted the network.
  1201  	defer func() {
  1202  		_ = network.Delete()
  1203  	}()
  1204  
  1205  	req := &ncproxygrpcv0.GetNetworkRequest{
  1206  		Name: networkName,
  1207  	}
  1208  	_, err = v0Service.GetNetwork(ctx, req)
  1209  	if err != nil {
  1210  		t.Fatalf("expected no error, instead got %v", err)
  1211  	}
  1212  }
  1213  
  1214  func TestGetNetwork_V0_Error_NoNetwork(t *testing.T) {
  1215  	ctx := context.Background()
  1216  
  1217  	networkingStore, closer, err := createTestNetworkingStore()
  1218  	if err != nil {
  1219  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1220  	}
  1221  	defer closer()
  1222  
  1223  	// setup test ncproxy grpc service
  1224  	agentCache := newComputeAgentCache()
  1225  	gService := newGRPCService(agentCache, networkingStore)
  1226  	v0Service := newV0ServiceWrapper(gService)
  1227  
  1228  	fakeNetworkName := t.Name() + "-network"
  1229  
  1230  	req := &ncproxygrpcv0.GetNetworkRequest{
  1231  		Name: fakeNetworkName,
  1232  	}
  1233  	_, err = v0Service.GetNetwork(ctx, req)
  1234  	if err == nil {
  1235  		t.Fatal("expected to get an error when attempting to get nonexistent network")
  1236  	}
  1237  }
  1238  
  1239  func TestGetNetwork_V0_Error_EmptyNetworkName(t *testing.T) {
  1240  	ctx := context.Background()
  1241  
  1242  	networkingStore, closer, err := createTestNetworkingStore()
  1243  	if err != nil {
  1244  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1245  	}
  1246  	defer closer()
  1247  
  1248  	// setup test ncproxy grpc service
  1249  	agentCache := newComputeAgentCache()
  1250  	gService := newGRPCService(agentCache, networkingStore)
  1251  	v0Service := newV0ServiceWrapper(gService)
  1252  
  1253  	req := &ncproxygrpcv0.GetNetworkRequest{
  1254  		Name: "",
  1255  	}
  1256  	_, err = v0Service.GetNetwork(ctx, req)
  1257  	if err == nil {
  1258  		t.Fatal("expected to get an error when network name is empty")
  1259  	}
  1260  }
  1261  
  1262  func TestGetNetworks_V0_NoError(t *testing.T) {
  1263  	ctx := context.Background()
  1264  
  1265  	networkingStore, closer, err := createTestNetworkingStore()
  1266  	if err != nil {
  1267  		t.Fatalf("failed to create a test ncproxy networking store with %v", err)
  1268  	}
  1269  	defer closer()
  1270  
  1271  	// setup test ncproxy grpc service
  1272  	agentCache := newComputeAgentCache()
  1273  	gService := newGRPCService(agentCache, networkingStore)
  1274  	v0Service := newV0ServiceWrapper(gService)
  1275  
  1276  	// create the test network
  1277  	networkName := t.Name() + "-network"
  1278  	network, err := createTestIPv4NATNetwork(networkName)
  1279  	if err != nil {
  1280  		t.Fatalf("failed to create test network with %v", err)
  1281  	}
  1282  	// defer cleanup in case of error. ignore error from the delete call here
  1283  	// since we may have already successfully deleted the network.
  1284  	defer func() {
  1285  		_ = network.Delete()
  1286  	}()
  1287  
  1288  	req := &ncproxygrpcv0.GetNetworksRequest{}
  1289  	resp, err := v0Service.GetNetworks(ctx, req)
  1290  	if err != nil {
  1291  		t.Fatalf("expected no error, instead got %v", err)
  1292  	}
  1293  	if !v0NetworkExists(networkName, resp.Networks) {
  1294  		t.Fatalf("failed to find created network")
  1295  	}
  1296  }
  1297  
  1298  func v0NetworkExists(targetName string, networks []*ncproxygrpcv0.GetNetworkResponse) bool {
  1299  	for _, resp := range networks {
  1300  		if resp.Name == targetName {
  1301  			return true
  1302  		}
  1303  	}
  1304  	return false
  1305  }
  1306  
  1307  func v0EndpointExists(targetName string, endpoints []*ncproxygrpcv0.GetEndpointResponse) bool {
  1308  	for _, resp := range endpoints {
  1309  		if resp.Name == targetName {
  1310  			return true
  1311  		}
  1312  	}
  1313  	return false
  1314  }
  1315  

View as plain text