From 5b636493dad848e92ef2e9c6d486fb3ea5784d3c Mon Sep 17 00:00:00 2001 From: seanpang-vmware Date: Mon, 23 Sep 2024 17:51:23 +0800 Subject: [PATCH] Add UT test for VPC service Per FSS enable requirement, UT coverage should be over 70%. --- pkg/nsx/services/vpc/builder_test.go | 105 ++++++++++++++ pkg/nsx/services/vpc/compare_test.go | 45 ++++++ pkg/nsx/services/vpc/vpc_test.go | 205 +++++++++++++++++++++++++-- 3 files changed, 347 insertions(+), 8 deletions(-) create mode 100644 pkg/nsx/services/vpc/compare_test.go diff --git a/pkg/nsx/services/vpc/builder_test.go b/pkg/nsx/services/vpc/builder_test.go index 571f8797b..647f88b35 100644 --- a/pkg/nsx/services/vpc/builder_test.go +++ b/pkg/nsx/services/vpc/builder_test.go @@ -205,3 +205,108 @@ func TestBuildNSXVPC(t *testing.T) { }) } } + +func Test_combineVPCIDAndLBSID(t *testing.T) { + type args struct { + vpcID string + lbsID string + } + tests := []struct { + name string + args args + want string + }{ + { + name: "pass", + args: args{ + vpcID: "fakeVpc", + lbsID: "fakeLbs", + }, + want: "fakeVpc_fakeLbs", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := combineVPCIDAndLBSID(tt.args.vpcID, tt.args.lbsID); got != tt.want { + t.Errorf("combineVPCIDAndLBSID() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_generateLBSKey(t *testing.T) { + emptyPath := "" + emptyVpcPath := "/fake/path/empty/vpc/" + okPath := "/fake/path/vpc/fake-vpc" + okId := "fake-id" + type args struct { + lbs model.LBService + } + tests := []struct { + name string + args args + want string + wantErr bool + }{ + { + name: "nil connectivity path", + args: args{ + lbs: model.LBService{ConnectivityPath: nil}, + }, + want: "", + wantErr: true, + }, + { + name: "empty connectivity path", + args: args{ + lbs: model.LBService{ConnectivityPath: &emptyPath}, + }, + want: "", + wantErr: true, + }, + { + name: "empty vpc id", + args: args{ + lbs: model.LBService{ConnectivityPath: &emptyVpcPath}, + }, + want: "", + wantErr: true, + }, + { + name: "nil lbs id", + args: args{ + lbs: model.LBService{ConnectivityPath: &okPath, Id: nil}, + }, + want: "", + wantErr: true, + }, + { + name: "empty lbs id", + args: args{ + lbs: model.LBService{ConnectivityPath: &okPath, Id: &emptyPath}, + }, + want: "", + wantErr: true, + }, + { + name: "empty lbs id", + args: args{ + lbs: model.LBService{ConnectivityPath: &okPath, Id: &okId}, + }, + want: "fake-vpc_fake-id", + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := generateLBSKey(tt.args.lbs) + if (err != nil) != tt.wantErr { + t.Errorf("generateLBSKey() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("generateLBSKey() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/nsx/services/vpc/compare_test.go b/pkg/nsx/services/vpc/compare_test.go new file mode 100644 index 000000000..26d5830a7 --- /dev/null +++ b/pkg/nsx/services/vpc/compare_test.go @@ -0,0 +1,45 @@ +package vpc + +import ( + "testing" + + "github.com/vmware/vsphere-automation-sdk-go/services/nsxt/model" + + "github.com/vmware-tanzu/nsx-operator/pkg/nsx/services/common" +) + +func TestIsVPCChanged(t *testing.T) { + type args struct { + nc common.VPCNetworkConfigInfo + vpc *model.Vpc + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "no change", + args: args{ + nc: common.VPCNetworkConfigInfo{PrivateIPs: []string{"1.1.1.1"}}, + vpc: &model.Vpc{PrivateIps: []string{"1.1.1.1"}}, + }, + want: false, + }, + { + name: "changed", + args: args{ + nc: common.VPCNetworkConfigInfo{PrivateIPs: []string{"1.1.1.1", "2.2.2.2"}}, + vpc: &model.Vpc{PrivateIps: []string{"1.1.1.1"}}, + }, + want: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := IsVPCChanged(tt.args.nc, tt.args.vpc); got != tt.want { + t.Errorf("IsVPCChanged() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/nsx/services/vpc/vpc_test.go b/pkg/nsx/services/vpc/vpc_test.go index bbcddd64d..69fce6e9c 100644 --- a/pkg/nsx/services/vpc/vpc_test.go +++ b/pkg/nsx/services/vpc/vpc_test.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "reflect" + "slices" "strings" "testing" @@ -13,7 +14,6 @@ import ( "github.com/stretchr/testify/assert" apierrors "github.com/vmware/vsphere-automation-sdk-go/lib/vapi/std/errors" "github.com/vmware/vsphere-automation-sdk-go/services/nsxt/model" - v1 "k8s.io/api/core/v1" "k8s.io/client-go/tools/cache" "sigs.k8s.io/controller-runtime/pkg/client" @@ -24,7 +24,7 @@ import ( "github.com/vmware-tanzu/nsx-operator/pkg/nsx" "github.com/vmware-tanzu/nsx-operator/pkg/nsx/ratelimiter" "github.com/vmware-tanzu/nsx-operator/pkg/nsx/services/common" - "github.com/vmware-tanzu/nsx-operator/pkg/nsx/util" + nsxUtil "github.com/vmware-tanzu/nsx-operator/pkg/nsx/util" ) var ( @@ -219,14 +219,21 @@ func TestGetSharedVPCNamespaceFromNS(t *testing.T) { ctx := context.Background() + mockNs := &v1.Namespace{} + k8sClient.EXPECT().Get(ctx, gomock.Any(), mockNs).Return(errors.New("fake-error")) + got, err := service.getSharedVPCNamespaceFromNS("fake-ns") + assert.NotNil(t, err) + assert.Equal(t, "", got) + tests := []struct { name string ns string anno map[string]string expected string }{ - {"1", "test-ns-1", map[string]string{"nsx.vmware.com/vpc_network_config": "default"}, ""}, - {"2", "test-ns-2", map[string]string{"nsx.vmware.com/vpc_network_config": "infra", "nsx.vmware.com/shared_vpc_namespace": "kube-system"}, "kube-system"}, + {"1", "test-ns-1", map[string]string{}, ""}, + {"2", "test-ns-2", map[string]string{"nsx.vmware.com/vpc_network_config": "default"}, ""}, + {"3", "test-ns-3", map[string]string{"nsx.vmware.com/vpc_network_config": "infra", "nsx.vmware.com/shared_vpc_namespace": "kube-system"}, "kube-system"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -238,7 +245,8 @@ func TestGetSharedVPCNamespaceFromNS(t *testing.T) { }) ns, _err := service.getSharedVPCNamespaceFromNS(tt.ns) assert.Equal(t, tt.expected, ns) - assert.Equal(t, nil, _err) + assert.Nil(t, _err) + }) } @@ -556,7 +564,7 @@ func TestGetLbProvider(t *testing.T) { patch = gomonkey.ApplyPrivateMethod(reflect.TypeOf(vpcService.Service.NSXClient.Cluster), "HttpGet", func(_ *nsx.Cluster, path string) (map[string]interface{}, error) { retry++ if strings.Contains(path, "alb-endpoint") { - return nil, util.HttpCommonError + return nil, nsxUtil.HttpCommonError } else { return nil, nil } @@ -571,7 +579,7 @@ func TestGetLbProvider(t *testing.T) { patch = gomonkey.ApplyPrivateMethod(reflect.TypeOf(vpcService.Service.NSXClient.Cluster), "HttpGet", func(_ *nsx.Cluster, path string) (map[string]interface{}, error) { retry++ if strings.Contains(path, "alb-endpoint") { - return nil, util.HttpNotFoundError + return nil, nsxUtil.HttpNotFoundError } else { return nil, nil } @@ -595,7 +603,7 @@ func TestGetLbProvider(t *testing.T) { if strings.Contains(path, "alb-endpoint") { return nil, nil } else { - return nil, util.HttpNotFoundError + return nil, nsxUtil.HttpNotFoundError } }) vpcService.LbsStore.Add(&model.LBService{Id: &defaultLBSName, ConnectivityPath: common.String("12345")}) @@ -983,3 +991,184 @@ func TestGetLBSsFromNSXByVPC(t *testing.T) { }) } } + +func TestVPCService_RegisterVPCNetworkConfig(t *testing.T) { + service, _, _ := createService(t) + + info := common.VPCNetworkConfigInfo{ + IsDefault: false, + Org: "fake-org", + Name: "fake-name", + VPCConnectivityProfile: "fake-file", + NSXProject: "fake-project", + PrivateIPs: []string{"1.1.1.1/16"}, + DefaultSubnetSize: 16, + VPCPath: "fake-path", + } + + service.RegisterVPCNetworkConfig("fake-name", info) + _, exist := service.GetVPCNetworkConfig("non-exist") + assert.False(t, exist) + got, exist := service.GetVPCNetworkConfig("fake-name") + assert.True(t, exist) + reflect.DeepEqual(got, info) + +} + +func TestVPCService_UnRegisterVPCNetworkConfig(t *testing.T) { + service, _, _ := createService(t) + + info := common.VPCNetworkConfigInfo{ + IsDefault: false, + Org: "fake-org", + Name: "fake-name", + VPCConnectivityProfile: "fake-file", + NSXProject: "fake-project", + PrivateIPs: []string{"1.1.1.1/16"}, + DefaultSubnetSize: 16, + VPCPath: "fake-path", + } + + service.RegisterVPCNetworkConfig("fake-name", info) + got, exist := service.GetVPCNetworkConfig("fake-name") + assert.True(t, exist) + reflect.DeepEqual(got, info) + service.UnregisterVPCNetworkConfig("non-exist") + got, exist = service.GetVPCNetworkConfig("fake-name") + assert.True(t, exist) + reflect.DeepEqual(got, info) + service.UnregisterVPCNetworkConfig("fake-name") + got, exist = service.GetVPCNetworkConfig("fake-name") + assert.False(t, exist) + assert.Equal(t, common.VPCNetworkConfigInfo{}, got) + +} + +func TestVPCService_RegisterNamespaceNetworkconfigBinding(t *testing.T) { + + service, _, _ := createService(t) + + info := common.VPCNetworkConfigInfo{ + IsDefault: false, + Org: "fake-org", + Name: "fake-name", + VPCConnectivityProfile: "fake-file", + NSXProject: "fake-project", + PrivateIPs: []string{"1.1.1.1/16"}, + DefaultSubnetSize: 16, + VPCPath: "fake-path", + } + + service.RegisterVPCNetworkConfig("fake-name", info) + service.RegisterNamespaceNetworkconfigBinding("fake-ns", "fake-name") + got := service.GetVPCNetworkConfigByNamespace("fake-ns") + reflect.DeepEqual(info, got) + got = service.GetVPCNetworkConfigByNamespace("non-exist") + assert.Nil(t, got) + +} + +func TestVPCService_UnRegisterNamespaceNetworkconfigBinding(t *testing.T) { + + service, _, _ := createService(t) + + info := common.VPCNetworkConfigInfo{ + IsDefault: false, + Org: "fake-org", + Name: "fake-name", + VPCConnectivityProfile: "fake-file", + NSXProject: "fake-project", + PrivateIPs: []string{"1.1.1.1/16"}, + DefaultSubnetSize: 16, + VPCPath: "fake-path", + } + + service.RegisterVPCNetworkConfig("fake-name", info) + service.RegisterNamespaceNetworkconfigBinding("fake-ns", "fake-name") + got := service.GetVPCNetworkConfigByNamespace("fake-ns") + reflect.DeepEqual(info, got) + got = service.GetVPCNetworkConfigByNamespace("non-exist") + assert.Nil(t, got) + service.UnRegisterNamespaceNetworkconfigBinding("fake-ns") + got = service.GetVPCNetworkConfigByNamespace("fake-ns") + assert.Nil(t, got) + +} + +func TestVPCService_GetNamespacesByNetworkconfigName(t *testing.T) { + service, _, _ := createService(t) + service.RegisterNamespaceNetworkconfigBinding("ns1", "fake-config") + service.RegisterNamespaceNetworkconfigBinding("ns2", "fake-config") + service.RegisterNamespaceNetworkconfigBinding("ns3", "dummy-config") + ret := service.GetNamespacesByNetworkconfigName("dummy-config") + assert.Equal(t, 1, len(ret)) + assert.Equal(t, "ns3", ret[0]) + ret = service.GetNamespacesByNetworkconfigName("non-exist") + assert.Equal(t, 0, len(ret)) + ret = service.GetNamespacesByNetworkconfigName("fake-config") + assert.Equal(t, 2, len(ret)) + assert.True(t, slices.Contains(ret, "ns1")) + assert.True(t, slices.Contains(ret, "ns2")) +} + +func TestVPCService_GetVPCNetworkConfigByNamespace(t *testing.T) { + service, _, _ := createService(t) + + info := common.VPCNetworkConfigInfo{ + IsDefault: false, + Org: "fake-org", + Name: "fake-name", + VPCConnectivityProfile: "fake-file", + NSXProject: "fake-project", + PrivateIPs: []string{"1.1.1.1/16"}, + DefaultSubnetSize: 16, + VPCPath: "fake-path", + } + + service.RegisterNamespaceNetworkconfigBinding("fake-ns", "fake-name") + got := service.GetVPCNetworkConfigByNamespace("non-exist") + assert.Nil(t, got) + got = service.GetVPCNetworkConfigByNamespace("fake-ns") + assert.Nil(t, got) + service.RegisterVPCNetworkConfig("fake-name", info) + got = service.GetVPCNetworkConfigByNamespace("fake-ns") + reflect.DeepEqual(info, got) +} + +func TestVPCService_ValidateNetworkConfig(t *testing.T) { + service, _, _ := createService(t) + + tests := []struct { + name string + nc common.VPCNetworkConfigInfo + want bool + }{ + { + name: "is pre-created vpc", + nc: common.VPCNetworkConfigInfo{VPCPath: "fake-path"}, + want: true, + }, + { + name: "pre-created vpc with nil private ips", + nc: common.VPCNetworkConfigInfo{VPCPath: "", PrivateIPs: nil}, + want: false, + }, + { + name: "pre-created vpc with empty private ips", + nc: common.VPCNetworkConfigInfo{VPCPath: "", PrivateIPs: []string{}}, + want: false, + }, + { + name: "pre-created vpc with valid private ips", + nc: common.VPCNetworkConfigInfo{VPCPath: "", PrivateIPs: []string{"1.1.1.1/16"}}, + want: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := service.ValidateNetworkConfig(tt.nc); got != tt.want { + t.Errorf("VPCService.ValidateNetworkConfig() = %v, want %v", got, tt.want) + } + }) + } +}