refactor: code dup reduction in tests

Signed-off-by: Boris Glimcher <[email protected]>
opiproject · Oct 24, 2023 · ae6a0dc · ae6a0dc
1 parent 02cf2ee
commit ae6a0dc
Show file tree

Hide file tree

Showing 8 changed files with 246 additions and 438 deletions.
diff --git a/pkg/bridge/bridge_test.go b/pkg/bridge/bridge_test.go
@@ -10,18 +10,14 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"log"
 	"net"
 	"reflect"
 	"testing"
 
-	"github.com/philippgille/gokv/gomap"
 	"github.com/stretchr/testify/mock"
 	"github.com/vishvananda/netlink"
 
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -255,36 +251,20 @@ func Test_CreateLogicalBridge(t *testing.T) {
 	// run tests
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			// start GRPC mockup server
 			ctx := context.Background()
-			mockNetlink := mocks.NewNetlink(t)
-			mockFrr := mocks.NewFrr(t)
-			store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
-			opi := NewServerWithArgs(mockNetlink, mockFrr, store)
-			conn, err := grpc.DialContext(ctx,
-				"",
-				grpc.WithTransportCredentials(insecure.NewCredentials()),
-				grpc.WithContextDialer(dialer(opi)))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer func(conn *grpc.ClientConn) {
-				err := conn.Close()
-				if err != nil {
-					log.Fatal(err)
-				}
-			}(conn)
-			client := pb.NewLogicalBridgeServiceClient(conn)
+			env := newTestEnv(ctx, t)
+			defer env.Close()
+			client := pb.NewLogicalBridgeServiceClient(env.conn)
 
 			if tt.exist {
-				_ = opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
+				_ = env.opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
 			}
 			if tt.out != nil {
 				tt.out = utils.ProtoClone(tt.out)
 				tt.out.Name = testLogicalBridgeName
 			}
 			if tt.on != nil {
-				tt.on(mockNetlink, mockFrr, tt.errMsg)
+				tt.on(env.mockNetlink, env.mockFrr, tt.errMsg)
 			}
 
 			request := &pb.CreateLogicalBridgeRequest{LogicalBridge: tt.in, LogicalBridgeId: tt.id}
@@ -424,32 +404,16 @@ func Test_DeleteLogicalBridge(t *testing.T) {
 	// run tests
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			// start GRPC mockup server
 			ctx := context.Background()
-			mockNetlink := mocks.NewNetlink(t)
-			mockFrr := mocks.NewFrr(t)
-			store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
-			opi := NewServerWithArgs(mockNetlink, mockFrr, store)
-			conn, err := grpc.DialContext(ctx,
-				"",
-				grpc.WithTransportCredentials(insecure.NewCredentials()),
-				grpc.WithContextDialer(dialer(opi)))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer func(conn *grpc.ClientConn) {
-				err := conn.Close()
-				if err != nil {
-					log.Fatal(err)
-				}
-			}(conn)
-			client := pb.NewLogicalBridgeServiceClient(conn)
+			env := newTestEnv(ctx, t)
+			defer env.Close()
+			client := pb.NewLogicalBridgeServiceClient(env.conn)
 
 			fname1 := resourceIDToFullName(tt.in)
-			_ = opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
+			_ = env.opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
 
 			if tt.on != nil {
-				tt.on(mockNetlink, mockFrr, tt.errMsg)
+				tt.on(env.mockNetlink, env.mockFrr, tt.errMsg)
 			}
 
 			request := &pb.DeleteLogicalBridgeRequest{Name: fname1, AllowMissing: tt.missing}
@@ -516,29 +480,13 @@ func Test_UpdateLogicalBridge(t *testing.T) {
 	// run tests
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			// start GRPC mockup server
 			ctx := context.Background()
-			mockNetlink := mocks.NewNetlink(t)
-			mockFrr := mocks.NewFrr(t)
-			store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
-			opi := NewServerWithArgs(mockNetlink, mockFrr, store)
-			conn, err := grpc.DialContext(ctx,
-				"",
-				grpc.WithTransportCredentials(insecure.NewCredentials()),
-				grpc.WithContextDialer(dialer(opi)))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer func(conn *grpc.ClientConn) {
-				err := conn.Close()
-				if err != nil {
-					log.Fatal(err)
-				}
-			}(conn)
-			client := pb.NewLogicalBridgeServiceClient(conn)
+			env := newTestEnv(ctx, t)
+			defer env.Close()
+			client := pb.NewLogicalBridgeServiceClient(env.conn)
 
 			if tt.exist {
-				_ = opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
+				_ = env.opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
 			}
 			if tt.out != nil {
 				tt.out = utils.ProtoClone(tt.out)
@@ -598,28 +546,12 @@ func Test_GetLogicalBridge(t *testing.T) {
 	// run tests
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			// start GRPC mockup server
 			ctx := context.Background()
-			mockNetlink := mocks.NewNetlink(t)
-			mockFrr := mocks.NewFrr(t)
-			store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
-			opi := NewServerWithArgs(mockNetlink, mockFrr, store)
-			conn, err := grpc.DialContext(ctx,
-				"",
-				grpc.WithTransportCredentials(insecure.NewCredentials()),
-				grpc.WithContextDialer(dialer(opi)))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer func(conn *grpc.ClientConn) {
-				err := conn.Close()
-				if err != nil {
-					log.Fatal(err)
-				}
-			}(conn)
-			client := pb.NewLogicalBridgeServiceClient(conn)
+			env := newTestEnv(ctx, t)
+			defer env.Close()
+			client := pb.NewLogicalBridgeServiceClient(env.conn)
 
-			_ = opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
+			_ = env.opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
 
 			request := &pb.GetLogicalBridgeRequest{Name: tt.in}
 			response, err := client.GetLogicalBridge(ctx, request)
@@ -703,30 +635,14 @@ func Test_ListLogicalBridges(t *testing.T) {
 	// run tests
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			// start GRPC mockup server
 			ctx := context.Background()
-			mockNetlink := mocks.NewNetlink(t)
-			mockFrr := mocks.NewFrr(t)
-			store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
-			opi := NewServerWithArgs(mockNetlink, mockFrr, store)
-			conn, err := grpc.DialContext(ctx,
-				"",
-				grpc.WithTransportCredentials(insecure.NewCredentials()),
-				grpc.WithContextDialer(dialer(opi)))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer func(conn *grpc.ClientConn) {
-				err := conn.Close()
-				if err != nil {
-					log.Fatal(err)
-				}
-			}(conn)
-			client := pb.NewLogicalBridgeServiceClient(conn)
+			env := newTestEnv(ctx, t)
+			defer env.Close()
+			client := pb.NewLogicalBridgeServiceClient(env.conn)
 
-			_ = opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
-			opi.ListHelper[testLogicalBridgeName] = false
-			opi.Pagination["existing-pagination-token"] = 1
+			_ = env.opi.store.Set(testLogicalBridgeName, &testLogicalBridgeWithStatus)
+			env.opi.ListHelper[testLogicalBridgeName] = false
+			env.opi.Pagination["existing-pagination-token"] = 1
 
 			request := &pb.ListLogicalBridgesRequest{PageSize: tt.size, PageToken: tt.token}
 			response, err := client.ListLogicalBridges(ctx, request)

diff --git a/pkg/bridge/common.go b/pkg/bridge/common.go
@@ -10,11 +10,16 @@ import (
 	"log"
 	"net"
 	"sort"
+	"testing"
 
+	"github.com/philippgille/gokv/gomap"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/test/bufconn"
 
 	pb "github.com/opiproject/opi-api/network/evpn-gw/v1alpha1/gen/go"
+	"github.com/opiproject/opi-evpn-bridge/pkg/utils"
+	"github.com/opiproject/opi-evpn-bridge/pkg/utils/mocks"
 )
 
 func sortLogicalBridges(bridges []*pb.LogicalBridge) {
@@ -32,6 +37,37 @@ const (
 	tenantbridgeName = "br-tenant"
 )
 
+type testEnv struct {
+	mockNetlink *mocks.Netlink
+	mockFrr     *mocks.Frr
+	opi         *Server
+	conn        *grpc.ClientConn
+}
+
+func (e *testEnv) Close() {
+	err := e.conn.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func newTestEnv(ctx context.Context, t *testing.T) *testEnv {
+	store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
+	env := &testEnv{}
+	env.mockNetlink = mocks.NewNetlink(t)
+	env.mockFrr = mocks.NewFrr(t)
+	env.opi = NewServerWithArgs(env.mockNetlink, env.mockFrr, store)
+	conn, err := grpc.DialContext(ctx,
+		"",
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithContextDialer(dialer(env.opi)))
+	if err != nil {
+		log.Fatal(err)
+	}
+	env.conn = conn
+	return env
+}
+
 func dialer(opi *Server) func(context.Context, string) (net.Conn, error) {
 	listener := bufconn.Listen(1024 * 1024)
 	server := grpc.NewServer()

diff --git a/pkg/port/common.go b/pkg/port/common.go
@@ -10,13 +10,18 @@ import (
 	"log"
 	"net"
 	"sort"
+	"testing"
 
+	"github.com/philippgille/gokv/gomap"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/test/bufconn"
 	"google.golang.org/protobuf/proto"
 
 	pb "github.com/opiproject/opi-api/network/evpn-gw/v1alpha1/gen/go"
 	pc "github.com/opiproject/opi-api/network/opinetcommon/v1alpha1/gen/go"
+	"github.com/opiproject/opi-evpn-bridge/pkg/utils"
+	"github.com/opiproject/opi-evpn-bridge/pkg/utils/mocks"
 )
 
 func sortBridgePorts(ports []*pb.BridgePort) {
@@ -61,6 +66,37 @@ var (
 	}
 )
 
+type testEnv struct {
+	mockNetlink *mocks.Netlink
+	mockFrr     *mocks.Frr
+	opi         *Server
+	conn        *grpc.ClientConn
+}
+
+func (e *testEnv) Close() {
+	err := e.conn.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func newTestEnv(ctx context.Context, t *testing.T) *testEnv {
+	store := gomap.NewStore(gomap.Options{Codec: utils.ProtoCodec{}})
+	env := &testEnv{}
+	env.mockNetlink = mocks.NewNetlink(t)
+	env.mockFrr = mocks.NewFrr(t)
+	env.opi = NewServerWithArgs(env.mockNetlink, env.mockFrr, store)
+	conn, err := grpc.DialContext(ctx,
+		"",
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithContextDialer(dialer(env.opi)))
+	if err != nil {
+		log.Fatal(err)
+	}
+	env.conn = conn
+	return env
+}
+
 func dialer(opi *Server) func(context.Context, string) (net.Conn, error) {
 	listener := bufconn.Listen(1024 * 1024)
 	server := grpc.NewServer()