add coverage and tests to utils/utils.go (#31)

Author: cyrilst

.gitignore

@@ -12,5 +12,9 @@ doc/*.xml
 # packages
 sshproxy_*.tar.gz
 
+# coverage outputs
+test/coverage.out
+test/coverage.html
+
 # benchmark results
 benchmarks/results

Makefile

@@ -90,7 +90,8 @@ check:
 	$(GO) vet $(TEST)
 	staticcheck ./...
 	staticcheck $(TEST)
-	$(GO) test -failfast -race -count=1 -timeout=10s ./...
+	$(GO) test -coverprofile=test/coverage.out -failfast -race -count=1 -timeout=10s ./...
+	$(GO) tool cover -html=test/coverage.out -o test/coverage.html
 
 test:
 	cd test && bash ./run.sh
@@ -100,6 +101,6 @@ benchmark:
 	$(GO) test -failfast -race -count=6 -bench=. -run=^# -benchmem ./... | tee benchmarks/results/$(DATE)-$(COMMIT)
 
 clean:
-	rm -f $(EXE) $(MANDOC) doc/*.xml sshproxy_*.tar.gz
+	rm -f $(EXE) $(MANDOC) doc/*.xml sshproxy_*.tar.gz test/coverage.*
 
 .PHONY: all exe doc install install-doc-man install-binaries package fmt get-deps check test benchmark clean

pkg/utils/utils.go

@@ -50,7 +50,12 @@ func SplitHostPort(hostport string) (string, string, error) {
 	return host, strconv.Itoa(portNum), nil
 }
 
-// GetGroupUser returns a map of group memberships for the specifised user.
+// Mocking user.Lookup and user.LookupGroupId for testing.
+var userCurrent = user.Current
+var userLookup = user.Lookup
+var userLookupGroupId = user.LookupGroupId
+
+// GetGroupUser returns a map of group memberships for the specified user.
 //
 // It can be used to quickly check if a user is in a specified group.
 func GetGroupUser(u *user.User) (map[string]bool, error) {
@@ -61,7 +66,7 @@ func GetGroupUser(u *user.User) (map[string]bool, error) {
 
 	groups := make(map[string]bool)
 	for _, gid := range groupids {
-		g, err := user.LookupGroupId(gid)
+		g, err := userLookupGroupId(gid)
 		if err != nil {
 			return nil, err
 		}
@@ -76,7 +81,7 @@ func GetGroupUser(u *user.User) (map[string]bool, error) {
 //
 // It can be used to quickly check if a user is in a specified group.
 func GetGroups() (map[string]bool, error) {
-	u, err := user.Current()
+	u, err := userCurrent()
 	if err != nil {
 		return nil, err
 	}
@@ -93,7 +98,7 @@ func GetGroups() (map[string]bool, error) {
 //
 // It can be used to quickly check if a user is in a specified group.
 func GetGroupList(username string) (map[string]bool, error) {
-	u, err := user.Lookup(username)
+	u, err := userLookup(username)
 	if err != nil {
 		return nil, err
 	}

pkg/utils/utils_test.go

@@ -12,7 +12,11 @@ package utils
 
 import (
 	"errors"
+	"fmt"
+	"os/user"
 	"reflect"
+	"sort"
+	"strings"
 	"testing"
 	"time"
 )
@@ -97,6 +101,116 @@ func BenchmarkSplitHostPort(b *testing.B) {
 	}
 }
 
+func mockUserCurrent() (*user.User, error) {
+	return mockUserLookup("testuser")
+}
+
+func mockUserLookup(username string) (*user.User, error) {
+	var u user.User
+	if username == "root" {
+		u.Uid = "0"
+		u.Gid = "0"
+	} else if username == "testuser" {
+		u.Uid = "1000"
+		u.Gid = "1000"
+	} else if username == "userwithnogroupid" {
+		u.Uid = "1001"
+	} else if username == "userwithinvalidgroup" {
+		u.Uid = "1002"
+		u.Gid = "1002"
+	} else {
+		return &u, fmt.Errorf("user: unknown user %s", username)
+	}
+	u.Username = username
+	return &u, nil
+}
+
+func mockUserLookupGroupId(gid string) (*user.Group, error) {
+	var g user.Group
+	g.Gid = gid
+	if gid == "0" {
+		g.Name = "root"
+	} else if gid == "1000" {
+		g.Name = "testgroup"
+	} else {
+		return &g, fmt.Errorf("group: unknown group ID %s", gid)
+	}
+	return &g, nil
+}
+
+func BenchmarkGetGroupUser(b *testing.B) {
+	current, _ := userCurrent()
+	root, _ := userLookup("root")
+	for _, tt := range []*user.User{current, root} {
+		b.Run(tt.Username, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				GetGroupUser(tt)
+			}
+		})
+	}
+}
+
+func TestGetGroups(t *testing.T) {
+	userCurrent = mockUserCurrent
+	userLookupGroupId = mockUserLookupGroupId
+	groups, err := GetGroups()
+	if err != nil {
+		t.Errorf("GetGroups error = '%v', want nil", err)
+	} else if len(groups) < 1 {
+		t.Error("GetGroups must return at least one group")
+	}
+}
+
+func BenchmarkGetGroups(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		GetGroups()
+	}
+}
+
+var getGroupListTests = []struct {
+	user, groups, err string
+}{
+	{"root", "root", ""},
+	{"testuser", "testgroup", ""},
+	{"userwithnogroupid", "", "user: list groups for userwithnogroupid: invalid gid \"\""},
+	{"userwithinvalidgroup", "nonexistentgroup", "group: unknown group ID 1002"},
+	{"nonexistentuser", "nonexistentgroup", "user: unknown user nonexistentuser"},
+}
+
+func TestGetGroupList(t *testing.T) {
+	userLookup = mockUserLookup
+	userLookupGroupId = mockUserLookupGroupId
+	for _, tt := range getGroupListTests {
+		groups, err := GetGroupList(tt.user)
+		if err != nil {
+			if fmt.Sprintf("%s", err) != tt.err {
+				t.Errorf("GetGroupList error = '%v', want '%v'", err, tt.err)
+			}
+		} else {
+			g := make([]string, 0, len(groups))
+			for group := range groups {
+				g = append(g, group)
+			}
+			sort.Strings(g)
+			if strings.Join(g, " ") != tt.groups {
+				t.Errorf("GetGroupList groups = %v, want %v", strings.Join(g, " "), tt.groups)
+			}
+		}
+	}
+}
+
+func BenchmarkGetGroupList(b *testing.B) {
+	for _, tt := range getGroupListTests {
+		if tt.err == "" {
+			b.Run(tt.user, func(b *testing.B) {
+				for i := 0; i < b.N; i++ {
+					GetGroupList(tt.user)
+				}
+			})
+		}
+	}
+}
+
 func mockNetLookupHost(host string) ([]string, error) {
 	if host == "err" {
 		return nil, errors.New("LookupHost error")
@@ -106,6 +220,17 @@ func mockNetLookupHost(host string) ([]string, error) {
 	return []string{"1.1.1.1", "2.2.2.2", "3.3.3.3"}, nil
 }
 
+func BenchmarkNormalizeHostPort(b *testing.B) {
+	netLookupHost = mockNetLookupHost
+	for _, tt := range []string{"127.0.0.1", "127.0.0.1:123", "server1", "server1:123", "host:port:invalid", "err"} {
+		b.Run(tt, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				normalizeHostPort(tt)
+			}
+		})
+	}
+}
+
 var matchSourceTests = []struct {
 	source, sshdHostport string
 	want                 bool
@@ -160,6 +285,16 @@ var matchSourceTests = []struct {
 		"server2",
 		true,
 	},
+	{
+		"127.0.0.1:22",
+		"127.0.0.1:122",
+		false,
+	},
+	{
+		"127.0.0.1:22",
+		"127.0.0.2:22",
+		false,
+	},
 }
 
 func TestMatchSource(t *testing.T) {