Merge branch 'master' of gitlab.com:gitlab-org/gitaly into process_io_statsprocess_io_stats

39 files changed, 1108 insertions, 793 deletions

diff --git a/Makefile b/Makefile
index 1a4e9c5f8..c1e52f736 100644
--- a/Makefile
+++ b/Makefile
@@ -106,6 +106,10 @@ notice: $(TARGET_SETUP) $(GOVENDOR)
 notice-up-to-date: $(TARGET_SETUP) $(GOVENDOR)
 	@(cd $(PKG_BUILD_DIR) && govendor license -template _support/notice.template | cmp - NOTICE) || (echo >&2 "NOTICE requires update: 'make notice'" && false)
 
+.PHONY: codeclimate-report
+codeclimate-report:
+	docker run --env CODECLIMATE_CODE="$(BUILD_DIR)" --volume "$(BUILD_DIR)":/code --volume /var/run/docker.sock:/var/run/docker.sock --volume /tmp/cc:/tmp/cc codeclimate/codeclimate analyze -f text
+
 .PHONY: clean
 clean:
 	rm -rf $(TARGET_DIR) $(TEST_REPO) $(TEST_REPO_STORAGE_PATH) ./internal/service/ssh/gitaly-*-pack .ruby-bundle
diff --git a/STYLE.md b/STYLE.md
index 4b8ccbfac..300dfa0ab 100644
--- a/STYLE.md
+++ b/STYLE.md
@@ -41,6 +41,17 @@ interpolating strings. The `%q` operator quotes strings and escapes
 spaces and non-printable characters. This can save a lot of debugging
 time.
 
+## Return statements
+
+### Don't use "naked return"
+
+In a function with named return variables it is valid to have a plain
+("naked") `return` statement, which will return the named return
+variables.
+
+In Gitaly we don't use this feature. If the function returns one or
+more values, then always pass them to `return`.
+
 ## Tests
 
 ### Table-driven tests
diff --git a/internal/server/auth_test.go b/internal/server/auth_test.go
index 176ddd189..2d14d47c9 100644
--- a/internal/server/auth_test.go
+++ b/internal/server/auth_test.go
@@ -60,14 +60,13 @@ func TestAuthFailures(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		t.Log(tc.desc)
-		connOpts := append(tc.opts, grpc.WithInsecure())
-		func() {
+		t.Run(tc.desc, func(t *testing.T) {
+			connOpts := append(tc.opts, grpc.WithInsecure())
 			conn, err := dial(connOpts)
 			require.NoError(t, err, tc.desc)
 			defer conn.Close()
 			testhelper.AssertGrpcError(t, healthCheck(conn), tc.code, "")
-		}()
+		})
 	}
 }
 
@@ -104,16 +103,15 @@ func TestAuthSuccess(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		config.Config.Auth.Token = tc.token
-		config.Config.Auth.Transitioning = !tc.required
-		t.Logf("%+v", config.Config.Auth)
-		connOpts := append(tc.opts, grpc.WithInsecure())
-		func() {
+		t.Run(tc.desc, func(t *testing.T) {
+			config.Config.Auth.Token = tc.token
+			config.Config.Auth.Transitioning = !tc.required
+			connOpts := append(tc.opts, grpc.WithInsecure())
 			conn, err := dial(connOpts)
 			require.NoError(t, err, tc.desc)
 			defer conn.Close()
 			assert.NoError(t, healthCheck(conn), tc.desc)
-		}()
+		})
 	}
 }
 
diff --git a/internal/service/blob/get_blob_test.go b/internal/service/blob/get_blob_test.go
index c0467629a..2440fa23d 100644
--- a/internal/service/blob/get_blob_test.go
+++ b/internal/service/blob/get_blob_test.go
@@ -15,10 +15,11 @@ import (
 )
 
 func TestSuccessfulGetBlob(t *testing.T) {
-	server, serverSocketPath := runBlobServer(t)
+	server := runBlobServer(t)
 	defer server.Stop()
 
-	client := newBlobClient(t, serverSocketPath)
+	client, conn := newBlobClient(t, serverSocketPath)
+	defer conn.Close()
 	maintenanceMdBlobData := testhelper.MustReadFile(t, "testdata/maintenance-md-blob.txt")
 	testCases := []struct {
 		desc     string
@@ -63,31 +64,33 @@ func TestSuccessfulGetBlob(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		t.Log(tc.desc)
-		request := &pb.GetBlobRequest{
-			Repository: testRepo,
-			Oid:        tc.oid,
-			Limit:      int64(tc.limit),
-		}
+		t.Run(tc.desc, func(t *testing.T) {
+			request := &pb.GetBlobRequest{
+				Repository: testRepo,
+				Oid:        tc.oid,
+				Limit:      int64(tc.limit),
+			}
 
-		stream, err := client.GetBlob(context.Background(), request)
-		require.NoError(t, err, "initiate RPC")
+			stream, err := client.GetBlob(context.Background(), request)
+			require.NoError(t, err, "initiate RPC")
 
-		reportedSize, reportedOid, data, err := getBlob(stream)
-		require.NoError(t, err, "consume response")
+			reportedSize, reportedOid, data, err := getBlob(stream)
+			require.NoError(t, err, "consume response")
 
-		require.Equal(t, int64(tc.size), reportedSize, "real blob size")
+			require.Equal(t, int64(tc.size), reportedSize, "real blob size")
 
-		require.NotEmpty(t, reportedOid)
-		require.True(t, bytes.Equal(tc.contents, data), "returned data exactly as expected")
+			require.NotEmpty(t, reportedOid)
+			require.True(t, bytes.Equal(tc.contents, data), "returned data exactly as expected")
+		})
 	}
 }
 
 func TestGetBlobNotFound(t *testing.T) {
-	server, serverSocketPath := runBlobServer(t)
+	server := runBlobServer(t)
 	defer server.Stop()
 
-	client := newBlobClient(t, serverSocketPath)
+	client, conn := newBlobClient(t, serverSocketPath)
+	defer conn.Close()
 
 	request := &pb.GetBlobRequest{
 		Repository: testRepo,
@@ -133,10 +136,11 @@ func getBlob(stream pb.BlobService_GetBlobClient) (int64, string, []byte, error)
 }
 
 func TestFailedGetBlobRequestDueToValidationError(t *testing.T) {
-	server, serverSocketPath := runBlobServer(t)
+	server := runBlobServer(t)
 	defer server.Stop()
 
-	client := newBlobClient(t, serverSocketPath)
+	client, conn := newBlobClient(t, serverSocketPath)
+	defer conn.Close()
 	oid := "d42783470dc29fde2cf459eb3199ee1d7e3f3a72"
 
 	rpcRequests := []pb.GetBlobRequest{
diff --git a/internal/service/blob/testhelper_test.go b/internal/service/blob/testhelper_test.go
index 37660be89..0253b03fc 100644
--- a/internal/service/blob/testhelper_test.go
+++ b/internal/service/blob/testhelper_test.go
@@ -14,12 +14,12 @@ import (
 )
 
 var (
-	testRepo = testhelper.TestRepository()
+	testRepo         = testhelper.TestRepository()
+	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
 )
 
-func runBlobServer(t *testing.T) (server *grpc.Server, serverSocketPath string) {
-	server = testhelper.NewTestGrpcServer(t)
-	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
+func runBlobServer(t *testing.T) *grpc.Server {
+	server := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 
 	if err != nil {
@@ -31,10 +31,10 @@ func runBlobServer(t *testing.T) (server *grpc.Server, serverSocketPath string)
 
 	go server.Serve(listener)
 
-	return
+	return server
 }
 
-func newBlobClient(t *testing.T, serverSocketPath string) pb.BlobServiceClient {
+func newBlobClient(t *testing.T, serverSocketPath string) (pb.BlobServiceClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -46,5 +46,5 @@ func newBlobClient(t *testing.T, serverSocketPath string) pb.BlobServiceClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewBlobServiceClient(conn)
+	return pb.NewBlobServiceClient(conn), conn
 }
diff --git a/internal/service/commit/between_test.go b/internal/service/commit/between_test.go
index e260cacd6..67167d815 100644
--- a/internal/service/commit/between_test.go
+++ b/internal/service/commit/between_test.go
@@ -13,10 +13,11 @@ import (
 )
 
 func TestSuccessfulCommitsBetween(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 	from := []byte("498214de67004b1da3d820901307bed2a68a8ef6") // branch-merged
 	to := []byte("e63f41fe459e62e1228fcef60d7189127aeba95a")   // master
 	fakeHash := []byte("f63f41fe459e62e1228fcef60d7189127aeba95a")
@@ -133,40 +134,44 @@ func TestSuccessfulCommitsBetween(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		commits := []*pb.GitCommit{}
-		t.Logf("test case: %v", tc.description)
-		rpcRequest := pb.CommitsBetweenRequest{
-			Repository: testRepo, From: tc.from, To: tc.to,
-		}
-
-		c, err := client.CommitsBetween(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		for {
-			resp, err := c.Recv()
-			if err == io.EOF {
-				break
-			} else if err != nil {
+		t.Run(tc.description, func(t *testing.T) {
+			commits := []*pb.GitCommit{}
+			rpcRequest := pb.CommitsBetweenRequest{
+				Repository: testRepo, From: tc.from, To: tc.to,
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitsBetween(ctx, &rpcRequest)
+			if err != nil {
 				t.Fatal(err)
 			}
-			commits = append(commits, resp.GetCommits()...)
-		}
 
-		for i, commit := range commits {
-			if !testhelper.CommitsEqual(commit, expectedCommits[i]) {
-				t.Fatalf("Expected commit\n%v\ngot\n%v", expectedCommits[i], commit)
+			for {
+				resp, err := c.Recv()
+				if err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				commits = append(commits, resp.GetCommits()...)
 			}
-		}
+
+			for i, commit := range commits {
+				if !testhelper.CommitsEqual(commit, expectedCommits[i]) {
+					t.Fatalf("Expected commit\n%v\ngot\n%v", expectedCommits[i], commit)
+				}
+			}
+		})
 	}
 }
 
 func TestFailedCommitsBetweenRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 	from := []byte("498214de67004b1da3d820901307bed2a68a8ef6")
@@ -222,18 +227,21 @@ func TestFailedCommitsBetweenRequest(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		t.Logf("test case: %v", tc.description)
-		rpcRequest := pb.CommitsBetweenRequest{
-			Repository: tc.repository, From: tc.from, To: tc.to,
-		}
-
-		c, err := client.CommitsBetween(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		err = drainCommitsBetweenResponse(c)
-		testhelper.AssertGrpcError(t, err, tc.code, "")
+		t.Run(tc.description, func(t *testing.T) {
+			rpcRequest := pb.CommitsBetweenRequest{
+				Repository: tc.repository, From: tc.from, To: tc.to,
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitsBetween(ctx, &rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = drainCommitsBetweenResponse(c)
+			testhelper.AssertGrpcError(t, err, tc.code, "")
+		})
 	}
 }
 
diff --git a/internal/service/commit/commits_by_message_test.go b/internal/service/commit/commits_by_message_test.go
index 2325fa76a..52fd0a8f1 100644
--- a/internal/service/commit/commits_by_message_test.go
+++ b/internal/service/commit/commits_by_message_test.go
@@ -15,10 +15,12 @@ import (
 )
 
 func TestSuccessfulCommitsByMessageRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	commits := []*pb.GitCommit{
 		{
@@ -114,41 +116,45 @@ func TestSuccessfulCommitsByMessageRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %v", testCase.desc)
-
-		request := testCase.request
-		request.Repository = testRepo
-
-		c, err := client.CommitsByMessage(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		receivedCommits := []*pb.GitCommit{}
-		for {
-			resp, err := c.Recv()
-			if err == io.EOF {
-				break
-			} else if err != nil {
+		t.Run(testCase.desc, func(t *testing.T) {
+
+			request := testCase.request
+			request.Repository = testRepo
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitsByMessage(ctx, request)
+			if err != nil {
 				t.Fatal(err)
 			}
 
-			receivedCommits = append(receivedCommits, resp.GetCommits()...)
-		}
+			receivedCommits := []*pb.GitCommit{}
+			for {
+				resp, err := c.Recv()
+				if err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+
+				receivedCommits = append(receivedCommits, resp.GetCommits()...)
+			}
 
-		require.Equal(t, len(testCase.expectedCommits), len(receivedCommits), "number of commits received")
+			require.Equal(t, len(testCase.expectedCommits), len(receivedCommits), "number of commits received")
 
-		for i, receivedCommit := range receivedCommits {
-			require.Equal(t, testCase.expectedCommits[i], receivedCommit, "mismatched commit")
-		}
+			for i, receivedCommit := range receivedCommits {
+				require.Equal(t, testCase.expectedCommits[i], receivedCommit, "mismatched commit")
+			}
+		})
 	}
 }
 
 func TestFailedCommitsByMessageRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
@@ -175,14 +181,17 @@ func TestFailedCommitsByMessageRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %v", testCase.desc)
+		t.Run(testCase.desc, func(t *testing.T) {
 
-		c, err := client.CommitsByMessage(context.Background(), testCase.request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitsByMessage(ctx, testCase.request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		testhelper.AssertGrpcError(t, drainCommitsByMessageResponse(c), testCase.code, "")
+			testhelper.AssertGrpcError(t, drainCommitsByMessageResponse(c), testCase.code, "")
+		})
 	}
 }
 
diff --git a/internal/service/commit/count_commits_test.go b/internal/service/commit/count_commits_test.go
index ae958d41e..698e30b49 100644
--- a/internal/service/commit/count_commits_test.go
+++ b/internal/service/commit/count_commits_test.go
@@ -1,6 +1,7 @@
 package commit
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
@@ -15,10 +16,11 @@ import (
 )
 
 func TestSuccessfulCountCommitsRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	testCases := []struct {
 		revision, path      []byte
@@ -69,47 +71,51 @@ func TestSuccessfulCountCommitsRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.desc)
+		t.Run(testCase.desc, func(t *testing.T) {
 
-		request := &pb.CountCommitsRequest{
-			Repository: testRepo,
-			Revision:   testCase.revision,
-		}
+			request := &pb.CountCommitsRequest{
+				Repository: testRepo,
+				Revision:   testCase.revision,
+			}
 
-		if testCase.before != "" {
-			before, err := time.Parse(time.RFC3339, testCase.before)
-			if err != nil {
-				t.Fatal(err)
+			if testCase.before != "" {
+				before, err := time.Parse(time.RFC3339, testCase.before)
+				if err != nil {
+					t.Fatal(err)
+				}
+				request.Before = &timestamp.Timestamp{Seconds: before.Unix()}
 			}
-			request.Before = &timestamp.Timestamp{Seconds: before.Unix()}
-		}
 
-		if testCase.after != "" {
-			after, err := time.Parse(time.RFC3339, testCase.after)
-			if err != nil {
-				t.Fatal(err)
+			if testCase.after != "" {
+				after, err := time.Parse(time.RFC3339, testCase.after)
+				if err != nil {
+					t.Fatal(err)
+				}
+				request.After = &timestamp.Timestamp{Seconds: after.Unix()}
 			}
-			request.After = &timestamp.Timestamp{Seconds: after.Unix()}
-		}
 
-		if testCase.path != nil {
-			request.Path = testCase.path
-		}
+			if testCase.path != nil {
+				request.Path = testCase.path
+			}
 
-		response, err := client.CountCommits(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			response, err := client.CountCommits(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		require.Equal(t, response.Count, testCase.count)
+			require.Equal(t, response.Count, testCase.count)
+		})
 	}
 }
 
 func TestFailedCountCommitsRequestDueToValidationError(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	revision := []byte("d42783470dc29fde2cf459eb3199ee1d7e3f3a72")
 
@@ -120,9 +126,12 @@ func TestFailedCountCommitsRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
+		t.Run(fmt.Sprintf("%v", rpcRequest), func(t *testing.T) {
 
-		_, err := client.CountCommits(context.Background(), &rpcRequest)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.CountCommits(ctx, &rpcRequest)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
diff --git a/internal/service/commit/find_all_commits_test.go b/internal/service/commit/find_all_commits_test.go
index c48759561..2e6b75743 100644
--- a/internal/service/commit/find_all_commits_test.go
+++ b/internal/service/commit/find_all_commits_test.go
@@ -31,10 +31,11 @@ func TestSuccessfulFindAllCommitsRequest(t *testing.T) {
 		}, nil
 	}
 
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	// Commits made on another branch in parallel to the normal commits below.
 	// Will be used to test topology ordering.
@@ -247,33 +248,37 @@ func TestSuccessfulFindAllCommitsRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %v", testCase.desc)
+		t.Run(testCase.desc, func(t *testing.T) {
 
-		request := testCase.request
-		request.Repository = testRepo
+			request := testCase.request
+			request.Repository = testRepo
 
-		c, err := client.FindAllCommits(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.FindAllCommits(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		receivedCommits := collectCommtsFromFindAllCommitsClient(t, c)
+			receivedCommits := collectCommtsFromFindAllCommitsClient(t, c)
 
-		require.Equal(t, len(testCase.expectedCommits), len(receivedCommits), "number of commits received")
+			require.Equal(t, len(testCase.expectedCommits), len(receivedCommits), "number of commits received")
 
-		for i, receivedCommit := range receivedCommits {
-			if !testhelper.CommitsEqual(receivedCommit, testCase.expectedCommits[i]) {
-				t.Fatalf("Expected commit\n%v\ngot\n%v", testCase.expectedCommits[i], receivedCommit)
+			for i, receivedCommit := range receivedCommits {
+				if !testhelper.CommitsEqual(receivedCommit, testCase.expectedCommits[i]) {
+					t.Fatalf("Expected commit\n%v\ngot\n%v", testCase.expectedCommits[i], receivedCommit)
+				}
 			}
-		}
+		})
 	}
 }
 
 func TestSuccessfulFindAllCommitsRequestWithAltGitObjectDirs(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	committerName := "Scrooge McDuck"
 	committerEmail := "scrooge@mcduck.com"
@@ -329,34 +334,38 @@ func TestSuccessfulFindAllCommitsRequestWithAltGitObjectDirs(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.desc)
-
-		request := &pb.FindAllCommitsRequest{
-			Repository: &pb.Repository{
-				StorageName:                   testRepo.StorageName,
-				RelativePath:                  testRepo.RelativePath,
-				GitAlternateObjectDirectories: testCase.altDirs,
-			},
-			Revision: currentHead,
-			MaxCount: 1,
-		}
+		t.Run(testCase.desc, func(t *testing.T) {
+
+			request := &pb.FindAllCommitsRequest{
+				Repository: &pb.Repository{
+					StorageName:                   testRepo.StorageName,
+					RelativePath:                  testRepo.RelativePath,
+					GitAlternateObjectDirectories: testCase.altDirs,
+				},
+				Revision: currentHead,
+				MaxCount: 1,
+			}
 
-		c, err := client.FindAllCommits(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.FindAllCommits(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		receivedCommits := collectCommtsFromFindAllCommitsClient(t, c)
+			receivedCommits := collectCommtsFromFindAllCommitsClient(t, c)
 
-		require.Equal(t, testCase.expectedCount, len(receivedCommits), "number of commits received")
+			require.Equal(t, testCase.expectedCount, len(receivedCommits), "number of commits received")
+		})
 	}
 }
 
 func TestFailedFindAllCommitsRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
@@ -378,15 +387,18 @@ func TestFailedFindAllCommitsRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %v", testCase.desc)
+		t.Run(testCase.desc, func(t *testing.T) {
 
-		c, err := client.FindAllCommits(context.Background(), testCase.request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.FindAllCommits(ctx, testCase.request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		err = drainFindAllCommitsResponse(c)
-		testhelper.AssertGrpcError(t, err, testCase.code, "")
+			err = drainFindAllCommitsResponse(c)
+			testhelper.AssertGrpcError(t, err, testCase.code, "")
+		})
 	}
 }
 
diff --git a/internal/service/commit/find_commit_test.go b/internal/service/commit/find_commit_test.go
index 019a0efb1..33724b85e 100644
--- a/internal/service/commit/find_commit_test.go
+++ b/internal/service/commit/find_commit_test.go
@@ -11,10 +11,11 @@ import (
 )
 
 func TestSuccessfulFindCommitRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	testCases := []struct {
 		description string
@@ -119,29 +120,32 @@ func TestSuccessfulFindCommitRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.description)
+		t.Run(testCase.description, func(t *testing.T) {
+			request := &pb.FindCommitRequest{
+				Repository: testRepo,
+				Revision:   []byte(testCase.revision),
+			}
 
-		request := &pb.FindCommitRequest{
-			Repository: testRepo,
-			Revision:   []byte(testCase.revision),
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			response, err := client.FindCommit(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		response, err := client.FindCommit(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if !testhelper.CommitsEqual(testCase.commit, response.Commit) {
-			t.Fatalf("Expected commit %v, got %v", testCase.commit, response.Commit)
-		}
+			if !testhelper.CommitsEqual(testCase.commit, response.Commit) {
+				t.Fatalf("Expected commit %v, got %v", testCase.commit, response.Commit)
+			}
+		})
 	}
 }
 
 func TestFailedFindCommitRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
 	testCases := []struct {
@@ -155,14 +159,16 @@ func TestFailedFindCommitRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.description)
-
-		request := &pb.FindCommitRequest{
-			Repository: testCase.repo,
-			Revision:   testCase.revision,
-		}
+		t.Run(testCase.description, func(t *testing.T) {
+			request := &pb.FindCommitRequest{
+				Repository: testCase.repo,
+				Revision:   testCase.revision,
+			}
 
-		_, err := client.FindCommit(context.Background(), request)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.FindCommit(ctx, request)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
diff --git a/internal/service/commit/find_commits_test.go b/internal/service/commit/find_commits_test.go
index 97310a252..265f9f95e 100644
--- a/internal/service/commit/find_commits_test.go
+++ b/internal/service/commit/find_commits_test.go
@@ -14,10 +14,11 @@ import (
 )
 
 func TestFindCommitsFields(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	expectedCommit := &pb.GitCommit{
 		Id:      "b83d6e391c22777fca1ed3012fce84f633d7fed0",
@@ -59,10 +60,11 @@ func TestFindCommitsFields(t *testing.T) {
 }
 
 func TestSuccessfulFindCommitsRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	testCases := []struct {
 		desc    string
diff --git a/internal/service/commit/isancestor_test.go b/internal/service/commit/isancestor_test.go
index c61fb1511..3cbab4502 100644
--- a/internal/service/commit/isancestor_test.go
+++ b/internal/service/commit/isancestor_test.go
@@ -18,10 +18,11 @@ import (
 )
 
 func TestCommitIsAncestorFailure(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	queries := []struct {
 		Request   *pb.CommitIsAncestorRequest
@@ -67,19 +68,24 @@ func TestCommitIsAncestorFailure(t *testing.T) {
 	}
 
 	for _, v := range queries {
-		if _, err := client.CommitIsAncestor(context.Background(), v.Request); err == nil {
-			t.Error("Expected to throw an error")
-		} else if grpc.Code(err) != v.ErrorCode {
-			t.Errorf(v.ErrMsg, err)
-		}
+		t.Run(fmt.Sprintf("%v", v.Request), func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			if _, err := client.CommitIsAncestor(ctx, v.Request); err == nil {
+				t.Error("Expected to throw an error")
+			} else if grpc.Code(err) != v.ErrorCode {
+				t.Errorf(v.ErrMsg, err)
+			}
+		})
 	}
 }
 
 func TestCommitIsAncestorSuccess(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	queries := []struct {
 		Request  *pb.CommitIsAncestorRequest
@@ -152,23 +158,28 @@ func TestCommitIsAncestorSuccess(t *testing.T) {
 	}
 
 	for _, v := range queries {
-		c, err := client.CommitIsAncestor(context.Background(), v.Request)
-		if err != nil {
-			t.Fatalf("CommitIsAncestor threw error unexpectedly: %v", err)
-		}
-
-		response := c.GetValue()
-		if response != v.Response {
-			t.Errorf(v.ErrMsg)
-		}
+		t.Run(fmt.Sprintf("%v", v.Request), func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitIsAncestor(ctx, v.Request)
+			if err != nil {
+				t.Fatalf("CommitIsAncestor threw error unexpectedly: %v", err)
+			}
+
+			response := c.GetValue()
+			if response != v.Response {
+				t.Errorf(v.ErrMsg)
+			}
+		})
 	}
 }
 
 func TestSuccessfulIsAncestorRequestWithAltGitObjectDirs(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	committerName := "Scrooge McDuck"
 	committerEmail := "scrooge@mcduck.com"
@@ -226,22 +237,25 @@ func TestSuccessfulIsAncestorRequestWithAltGitObjectDirs(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.desc)
-		request := &pb.CommitIsAncestorRequest{
-			Repository: &pb.Repository{
-				StorageName:                   testRepo.StorageName,
-				RelativePath:                  testRepo.RelativePath,
-				GitAlternateObjectDirectories: testCase.altDirs,
-			},
-			AncestorId: string(previousHead),
-			ChildId:    string(currentHead),
-		}
+		t.Run(testCase.desc, func(t *testing.T) {
+			request := &pb.CommitIsAncestorRequest{
+				Repository: &pb.Repository{
+					StorageName:                   testRepo.StorageName,
+					RelativePath:                  testRepo.RelativePath,
+					GitAlternateObjectDirectories: testCase.altDirs,
+				},
+				AncestorId: string(previousHead),
+				ChildId:    string(currentHead),
+			}
 
-		response, err := client.CommitIsAncestor(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			response, err := client.CommitIsAncestor(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		require.Equal(t, testCase.result, response.Value)
+			require.Equal(t, testCase.result, response.Value)
+		})
 	}
 }
diff --git a/internal/service/commit/languages_test.go b/internal/service/commit/languages_test.go
index 3e68fbbc5..360ace214 100644
--- a/internal/service/commit/languages_test.go
+++ b/internal/service/commit/languages_test.go
@@ -10,16 +10,19 @@ import (
 )
 
 func TestLanguages(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 	request := &pb.CommitLanguagesRequest{
 		Repository: testRepo,
 		Revision:   []byte("cb19058ecc02d01f8e4290b7e79cafd16a8839b6"),
 	}
 
-	resp, err := client.CommitLanguages(context.Background(), request)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	resp, err := client.CommitLanguages(ctx, request)
 	require.NoError(t, err)
 
 	require.NotZero(t, len(resp.Languages), "number of languages in response")
@@ -56,15 +59,18 @@ func languageEqual(expected, actual *pb.CommitLanguagesResponse_Language) bool {
 }
 
 func TestLanguagesEmptyRevision(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 	request := &pb.CommitLanguagesRequest{
 		Repository: testRepo,
 	}
 
-	resp, err := client.CommitLanguages(context.Background(), request)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	resp, err := client.CommitLanguages(ctx, request)
 	require.NoError(t, err)
 
 	require.NotZero(t, len(resp.Languages), "number of languages in response")
diff --git a/internal/service/commit/last_commit_for_path_test.go b/internal/service/commit/last_commit_for_path_test.go
index d1e12305c..a449304ed 100644
--- a/internal/service/commit/last_commit_for_path_test.go
+++ b/internal/service/commit/last_commit_for_path_test.go
@@ -14,10 +14,11 @@ import (
 )
 
 func TestSuccessfulLastCommitForPathRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	commit := &pb.GitCommit{
 		Id:      "570e7b2abdd848b95f2f578043fc23bd6f6fd24d",
@@ -61,28 +62,31 @@ func TestSuccessfulLastCommitForPathRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.desc)
-
-		request := &pb.LastCommitForPathRequest{
-			Repository: testRepo,
-			Revision:   []byte(testCase.revision),
-			Path:       []byte(testCase.path),
-		}
-
-		response, err := client.LastCommitForPath(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		require.Equal(t, testCase.commit, response.GetCommit(), "mismatched commits")
+		t.Run(testCase.desc, func(t *testing.T) {
+			request := &pb.LastCommitForPathRequest{
+				Repository: testRepo,
+				Revision:   []byte(testCase.revision),
+				Path:       []byte(testCase.path),
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			response, err := client.LastCommitForPath(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			require.Equal(t, testCase.commit, response.GetCommit(), "mismatched commits")
+		})
 	}
 }
 
 func TestFailedLastCommitForPathRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
@@ -109,9 +113,12 @@ func TestFailedLastCommitForPathRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %v", testCase.desc)
+		t.Run(testCase.desc, func(t *testing.T) {
 
-		_, err := client.LastCommitForPath(context.Background(), testCase.request)
-		testhelper.AssertGrpcError(t, err, testCase.code, "")
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.LastCommitForPath(ctx, testCase.request)
+			testhelper.AssertGrpcError(t, err, testCase.code, "")
+		})
 	}
 }
diff --git a/internal/service/commit/list_files_test.go b/internal/service/commit/list_files_test.go
index 6a69db952..2d9fe1448 100644
--- a/internal/service/commit/list_files_test.go
+++ b/internal/service/commit/list_files_test.go
@@ -2,6 +2,7 @@ package commit
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"testing"
 
@@ -49,10 +50,11 @@ func TestListFilesSuccess(t *testing.T) {
 		defaultBranchName = ref.DefaultBranchName
 	}()
 
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	tests := []struct {
 		revision string
@@ -94,45 +96,49 @@ func TestListFilesSuccess(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		var files [][]byte
-		t.Logf("test case: %q", test.revision)
-		rpcRequest := pb.ListFilesRequest{
-			Repository: testRepo, Revision: []byte(test.revision),
-		}
-
-		c, err := client.ListFiles(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		for {
-			resp, err := c.Recv()
-			if err == io.EOF {
-				break
-			} else if err != nil {
+		t.Run(fmt.Sprintf("test case: %q", test.revision), func(t *testing.T) {
+			var files [][]byte
+			rpcRequest := pb.ListFilesRequest{
+				Repository: testRepo, Revision: []byte(test.revision),
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.ListFiles(ctx, &rpcRequest)
+			if err != nil {
 				t.Fatal(err)
 			}
-			files = append(files, resp.GetPaths()...)
-		}
 
-		if len(files) != len(test.files) {
-			t.Errorf("incorrect number of files: %d != %d", len(files), len(test.files))
-			continue
-		}
+			for {
+				resp, err := c.Recv()
+				if err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				files = append(files, resp.GetPaths()...)
+			}
+
+			if len(files) != len(test.files) {
+				t.Errorf("incorrect number of files: %d != %d", len(files), len(test.files))
+				return
+			}
 
-		for i := range files {
-			if !bytes.Equal(files[i], test.files[i]) {
-				t.Errorf("%q != %q", files[i], test.files[i])
+			for i := range files {
+				if !bytes.Equal(files[i], test.files[i]) {
+					t.Errorf("%q != %q", files[i], test.files[i])
+				}
 			}
-		}
+		})
 	}
 }
 
 func TestListFilesFailure(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	tests := []struct {
 		repo     *pb.Repository
@@ -149,19 +155,22 @@ func TestListFilesFailure(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		t.Logf("test case: %q", test.desc)
+		t.Run(test.desc, func(t *testing.T) {
 
-		rpcRequest := pb.ListFilesRequest{
-			Repository: test.repo, Revision: []byte("master"),
-		}
+			rpcRequest := pb.ListFilesRequest{
+				Repository: test.repo, Revision: []byte("master"),
+			}
 
-		c, err := client.ListFiles(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.ListFiles(ctx, &rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		err = drainListFilesResponse(c)
-		testhelper.AssertGrpcError(t, err, test.code, "")
+			err = drainListFilesResponse(c)
+			testhelper.AssertGrpcError(t, err, test.code, "")
+		})
 	}
 }
 
diff --git a/internal/service/commit/raw_blame_test.go b/internal/service/commit/raw_blame_test.go
index 4daef297f..b7f5fd59c 100644
--- a/internal/service/commit/raw_blame_test.go
+++ b/internal/service/commit/raw_blame_test.go
@@ -1,6 +1,7 @@
 package commit
 
 import (
+	"fmt"
 	"io/ioutil"
 	"testing"
 
@@ -15,10 +16,11 @@ import (
 )
 
 func TestSuccessfulRawBlameRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	testCases := []struct {
 		revision, path, data []byte
@@ -41,38 +43,42 @@ func TestSuccessfulRawBlameRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: revision=%q path=%q", testCase.revision, testCase.path)
-
-		request := &pb.RawBlameRequest{
-			Repository: testRepo,
-			Revision:   testCase.revision,
-			Path:       testCase.path,
-		}
-
-		c, err := client.RawBlame(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		sr := streamio.NewReader(func() ([]byte, error) {
-			response, err := c.Recv()
-			return response.GetData(), err
+		t.Run(fmt.Sprintf("test case: revision=%q path=%q", testCase.revision, testCase.path), func(t *testing.T) {
+
+			request := &pb.RawBlameRequest{
+				Repository: testRepo,
+				Revision:   testCase.revision,
+				Path:       testCase.path,
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.RawBlame(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			sr := streamio.NewReader(func() ([]byte, error) {
+				response, err := c.Recv()
+				return response.GetData(), err
+			})
+
+			blame, err := ioutil.ReadAll(sr)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			require.Equal(t, testCase.data, blame, "blame data mismatched")
 		})
-
-		blame, err := ioutil.ReadAll(sr)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		require.Equal(t, testCase.data, blame, "blame data mismatched")
 	}
 }
 
 func TestFailedRawBlameRequest(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
@@ -106,20 +112,23 @@ func TestFailedRawBlameRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.description)
-
-		request := pb.RawBlameRequest{
-			Repository: testCase.repo,
-			Revision:   testCase.revision,
-			Path:       testCase.path,
-		}
-
-		c, err := client.RawBlame(context.Background(), &request)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		testhelper.AssertGrpcError(t, drainRawBlameResponse(c), testCase.code, "")
+		t.Run(testCase.description, func(t *testing.T) {
+
+			request := pb.RawBlameRequest{
+				Repository: testCase.repo,
+				Revision:   testCase.revision,
+				Path:       testCase.path,
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.RawBlame(ctx, &request)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			testhelper.AssertGrpcError(t, drainRawBlameResponse(c), testCase.code, "")
+		})
 	}
 }
 
diff --git a/internal/service/commit/stats_test.go b/internal/service/commit/stats_test.go
index 0d8757249..6b098893f 100644
--- a/internal/service/commit/stats_test.go
+++ b/internal/service/commit/stats_test.go
@@ -11,11 +11,14 @@ import (
 )
 
 func TestCommitStatsUnimplemented(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
-	_, err := client.CommitStats(context.Background(), &pb.CommitStatsRequest{Repository: testRepo, Revision: []byte("master")})
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	_, err := client.CommitStats(ctx, &pb.CommitStatsRequest{Repository: testRepo, Revision: []byte("master")})
 	testhelper.AssertGrpcError(t, err, codes.Unimplemented, "not implemented")
 }
diff --git a/internal/service/commit/testhelper_test.go b/internal/service/commit/testhelper_test.go
index 52af1f05f..0447c3d2e 100644
--- a/internal/service/commit/testhelper_test.go
+++ b/internal/service/commit/testhelper_test.go
@@ -3,16 +3,16 @@ package commit
 import (
 	"bytes"
 	"net"
+	"os"
 	"testing"
 	"time"
 
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/objectdirhandler"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
-	"gitlab.com/gitlab-org/gitaly/internal/supervisor"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 
+	log "github.com/Sirupsen/logrus"
 	"github.com/golang/protobuf/ptypes/timestamp"
-	"github.com/grpc-ecosystem/go-grpc-middleware"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
 
@@ -20,39 +20,36 @@ import (
 )
 
 var (
-	testRepo *pb.Repository
+	testRepo         = testhelper.TestRepository()
+	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
 )
 
-func startTestServices(t *testing.T) (service *grpc.Server, ruby *supervisor.Process, serverSocketPath string) {
-	testRepo = testhelper.TestRepository()
+func TestMain(m *testing.M) {
+	os.Exit(testMain(m))
+}
 
+func testMain(m *testing.M) int {
 	testhelper.ConfigureRuby()
 	ruby, err := rubyserver.Start()
 	if err != nil {
-		t.Fatal("ruby spawn failed")
+		log.Fatal(err)
 	}
-
-	service, serverSocketPath = runCommitServiceServer(t)
-	return
-}
-
-func stopTestServices(service *grpc.Server, ruby *supervisor.Process) {
-	ruby.Stop()
-	service.Stop()
+	defer ruby.Stop()
+	return m.Run()
 }
 
-func runCommitServiceServer(t *testing.T) (server *grpc.Server, serviceSocketPath string) {
-	server = grpc.NewServer(
-		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
-			objectdirhandler.Stream,
-		)),
-		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
-			objectdirhandler.Unary,
-		)),
+func startTestServices(t *testing.T) *grpc.Server {
+	server := testhelper.NewTestGrpcServer(
+		t,
+		[]grpc.StreamServerInterceptor{objectdirhandler.Stream},
+		[]grpc.UnaryServerInterceptor{objectdirhandler.Unary},
 	)
-	serviceSocketPath = testhelper.GetTemporaryGitalySocketFileName()
 
-	listener, err := net.Listen("unix", serviceSocketPath)
+	if err := os.RemoveAll(serverSocketPath); err != nil {
+		t.Fatal(err)
+	}
+
+	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal("failed to start server")
 	}
@@ -61,7 +58,7 @@ func runCommitServiceServer(t *testing.T) (server *grpc.Server, serviceSocketPat
 	reflection.Register(server)
 
 	go server.Serve(listener)
-	return
+	return server
 }
 
 func newCommitClient(t *testing.T, serviceSocketPath string) pb.CommitClient {
@@ -79,7 +76,7 @@ func newCommitClient(t *testing.T, serviceSocketPath string) pb.CommitClient {
 	return pb.NewCommitClient(conn)
 }
 
-func newCommitServiceClient(t *testing.T, serviceSocketPath string) pb.CommitServiceClient {
+func newCommitServiceClient(t *testing.T, serviceSocketPath string) (pb.CommitServiceClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -91,7 +88,7 @@ func newCommitServiceClient(t *testing.T, serviceSocketPath string) pb.CommitSer
 		t.Fatal(err)
 	}
 
-	return pb.NewCommitServiceClient(conn)
+	return pb.NewCommitServiceClient(conn), conn
 }
 
 func treeEntriesEqual(a, b *pb.TreeEntry) bool {
diff --git a/internal/service/commit/tree_entries_test.go b/internal/service/commit/tree_entries_test.go
index f35cd43c2..2279ef21c 100644
--- a/internal/service/commit/tree_entries_test.go
+++ b/internal/service/commit/tree_entries_test.go
@@ -1,6 +1,7 @@
 package commit
 
 import (
+	"fmt"
 	"io"
 	"testing"
 
@@ -23,10 +24,11 @@ func TestSuccessfulGetTreeEntries(t *testing.T) {
 	commitID := "913c66a37b4a45b9769037c55c2d238bd0942d2e"
 	rootOid := "faafbe7fe23fb83c664c78aaded9566c8f934412"
 
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	rootEntries := []*pb.TreeEntry{
 		{
@@ -218,20 +220,22 @@ func TestSuccessfulGetTreeEntries(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %s", testCase.description)
+		t.Run(testCase.description, func(t *testing.T) {
+			request := &pb.GetTreeEntriesRequest{
+				Repository: testRepo,
+				Revision:   testCase.revision,
+				Path:       testCase.path,
+			}
 
-		request := &pb.GetTreeEntriesRequest{
-			Repository: testRepo,
-			Revision:   testCase.revision,
-			Path:       testCase.path,
-		}
-
-		c, err := client.GetTreeEntries(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.GetTreeEntries(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		assertTreeEntriesReceived(t, c, testCase.entries)
+			assertTreeEntriesReceived(t, c, testCase.entries)
+		})
 	}
 }
 
@@ -265,10 +269,11 @@ func getTreeEntriesFromTreeEntryClient(t *testing.T, client pb.CommitService_Get
 }
 
 func TestFailedGetTreeEntriesRequestDueToValidationError(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	revision := []byte("d42783470dc29fde2cf459eb3199ee1d7e3f3a72")
 	path := []byte("a/b/c")
@@ -281,15 +286,17 @@ func TestFailedGetTreeEntriesRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
-
-		c, err := client.GetTreeEntries(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
+		t.Run(fmt.Sprintf("%v", rpcRequest), func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.GetTreeEntries(ctx, &rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		err = drainTreeEntriesResponse(c)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+			err = drainTreeEntriesResponse(c)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
 
diff --git a/internal/service/commit/tree_entry_test.go b/internal/service/commit/tree_entry_test.go
index a15d27896..ee3b89bb4 100644
--- a/internal/service/commit/tree_entry_test.go
+++ b/internal/service/commit/tree_entry_test.go
@@ -2,6 +2,7 @@ package commit
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"testing"
 
@@ -22,10 +23,11 @@ type treeEntry struct {
 }
 
 func TestSuccessfulTreeEntry(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	testCases := []struct {
 		revision          []byte
@@ -121,29 +123,33 @@ func TestSuccessfulTreeEntry(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: revision=%q path=%q", testCase.revision, testCase.path)
-
-		request := &pb.TreeEntryRequest{
-			Repository: testRepo,
-			Revision:   testCase.revision,
-			Path:       testCase.path,
-			Limit:      testCase.limit,
-		}
-
-		c, err := client.TreeEntry(context.Background(), request)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		assertExactReceivedTreeEntry(t, c, &testCase.expectedTreeEntry)
+		t.Run(fmt.Sprintf("test case: revision=%q path=%q", testCase.revision, testCase.path), func(t *testing.T) {
+
+			request := &pb.TreeEntryRequest{
+				Repository: testRepo,
+				Revision:   testCase.revision,
+				Path:       testCase.path,
+				Limit:      testCase.limit,
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.TreeEntry(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			assertExactReceivedTreeEntry(t, c, &testCase.expectedTreeEntry)
+		})
 	}
 }
 
 func TestFailedTreeEntryRequestDueToValidationError(t *testing.T) {
-	service, ruby, serverSocketPath := startTestServices(t)
-	defer stopTestServices(service, ruby)
+	server := startTestServices(t)
+	defer server.Stop()
 
-	client := newCommitServiceClient(t, serverSocketPath)
+	client, conn := newCommitServiceClient(t, serverSocketPath)
+	defer conn.Close()
 
 	revision := []byte("d42783470dc29fde2cf459eb3199ee1d7e3f3a72")
 	path := []byte("a/b/c")
@@ -156,15 +162,18 @@ func TestFailedTreeEntryRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
-
-		c, err := client.TreeEntry(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		err = drainTreeEntryResponse(c)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		t.Run(fmt.Sprintf("%+v", rpcRequest), func(t *testing.T) {
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.TreeEntry(ctx, &rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = drainTreeEntryResponse(c)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
 
diff --git a/internal/service/diff/commit_test.go b/internal/service/diff/commit_test.go
index 10583e8c6..d600e2be0 100644
--- a/internal/service/diff/commit_test.go
+++ b/internal/service/diff/commit_test.go
@@ -2,6 +2,7 @@ package diff
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"net"
 	"testing"
@@ -25,12 +26,15 @@ func TestSuccessfulCommitDiffRequest(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "742518b2be68fc750bb4c357c0df821a88113286"
 	leftCommit := "8a0f2ee90d940bfb0ba1e14e8214b0649056e4ab"
 	rpcRequest := &pb.CommitDiffRequest{Repository: testRepo, RightCommitId: rightCommit, LeftCommitId: leftCommit, IgnoreWhitespaceChange: false}
 
-	c, err := client.CommitDiff(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDiff(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -161,7 +165,8 @@ func TestSuccessfulCommitDiffRequestWithPaths(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "e4003da16c1c2c3fc4567700121b17bf8e591c6c"
 	leftCommit := "8a0f2ee90d940bfb0ba1e14e8214b0649056e4ab"
 	rpcRequest := &pb.CommitDiffRequest{
@@ -177,7 +182,9 @@ func TestSuccessfulCommitDiffRequestWithPaths(t *testing.T) {
 		},
 	}
 
-	c, err := client.CommitDiff(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDiff(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -232,7 +239,8 @@ func TestSuccessfulCommitDiffRequestWithTypeChangeDiff(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "184a47d38677e2e439964859b877ae9bc424ab11"
 	leftCommit := "80d56eb72ba5d77fd8af857eced17a7d0640cb82"
 	rpcRequest := &pb.CommitDiffRequest{
@@ -241,7 +249,9 @@ func TestSuccessfulCommitDiffRequestWithTypeChangeDiff(t *testing.T) {
 		LeftCommitId:  leftCommit,
 	}
 
-	c, err := client.CommitDiff(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDiff(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -276,7 +286,8 @@ func TestSuccessfulCommitDiffRequestWithIgnoreWhitespaceChange(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "e4003da16c1c2c3fc4567700121b17bf8e591c6c"
 	leftCommit := "8a0f2ee90d940bfb0ba1e14e8214b0649056e4ab"
 
@@ -343,34 +354,41 @@ func TestSuccessfulCommitDiffRequestWithIgnoreWhitespaceChange(t *testing.T) {
 	}
 
 	pathsAndDiffs := []struct {
+		desc  string
 		paths [][]byte
 		diffs []diff.Diff
 	}{
 		{
+			desc:  "whitespace paths",
 			paths: whitespacePaths,
 			diffs: expectedWhitespaceDiffs,
 		},
 		{
+			desc:  "whitespace paths and normal paths",
 			paths: append(whitespacePaths, normalPaths...),
 			diffs: append(expectedWhitespaceDiffs, expectedNormalDiffs...),
 		},
 	}
 
 	for _, entry := range pathsAndDiffs {
-		rpcRequest := &pb.CommitDiffRequest{
-			Repository:             testRepo,
-			RightCommitId:          rightCommit,
-			LeftCommitId:           leftCommit,
-			IgnoreWhitespaceChange: true,
-			Paths: entry.paths,
-		}
+		t.Run(entry.desc, func(t *testing.T) {
+			rpcRequest := &pb.CommitDiffRequest{
+				Repository:             testRepo,
+				RightCommitId:          rightCommit,
+				LeftCommitId:           leftCommit,
+				IgnoreWhitespaceChange: true,
+				Paths: entry.paths,
+			}
 
-		c, err := client.CommitDiff(context.Background(), rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitDiff(ctx, rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		assertExactReceivedDiffs(t, c, entry.diffs)
+			assertExactReceivedDiffs(t, c, entry.diffs)
+		})
 	}
 }
 
@@ -378,7 +396,8 @@ func TestSuccessfulCommitDiffRequestWithLimits(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "899d3d27b04690ac1cd9ef4d8a74fde0667c57f1"
 	leftCommit := "184a47d38677e2e439964859b877ae9bc424ab11"
 
@@ -531,35 +550,38 @@ func TestSuccessfulCommitDiffRequestWithLimits(t *testing.T) {
 	}
 
 	for _, requestAndResult := range requestsAndResults {
-		t.Logf("test case: %s", requestAndResult.desc)
-
-		request := requestAndResult.request
-		request.Repository = testRepo
-		request.LeftCommitId = leftCommit
-		request.RightCommitId = rightCommit
-
-		c, err := client.CommitDiff(context.Background(), &request)
-		if err != nil {
-			t.Fatal(err)
-		}
+		t.Run(requestAndResult.desc, func(t *testing.T) {
+
+			request := requestAndResult.request
+			request.Repository = testRepo
+			request.LeftCommitId = leftCommit
+			request.RightCommitId = rightCommit
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitDiff(ctx, &request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		receivedDiffs := getDiffsFromCommitDiffClient(t, c)
+			receivedDiffs := getDiffsFromCommitDiffClient(t, c)
 
-		require.Equal(t, len(requestAndResult.result), len(receivedDiffs), "number of diffs received")
-		for i, diff := range receivedDiffs {
-			if overflowMarker := requestAndResult.result[i].overflowMarker; overflowMarker {
-				require.Equal(t, overflowMarker, diff.OverflowMarker, "overflow marker")
-				continue
-			}
+			require.Equal(t, len(requestAndResult.result), len(receivedDiffs), "number of diffs received")
+			for i, diff := range receivedDiffs {
+				if overflowMarker := requestAndResult.result[i].overflowMarker; overflowMarker {
+					require.Equal(t, overflowMarker, diff.OverflowMarker, "overflow marker")
+					continue
+				}
 
-			require.Equal(t, requestAndResult.result[i].path, string(diff.FromPath), "path")
+				require.Equal(t, requestAndResult.result[i].path, string(diff.FromPath), "path")
 
-			collapsed := requestAndResult.result[i].collapsed
-			require.Equal(t, collapsed, diff.Collapsed, "collapsed")
-			if collapsed {
-				require.Empty(t, diff.Patch, "patch")
+				collapsed := requestAndResult.result[i].collapsed
+				require.Equal(t, collapsed, diff.Collapsed, "collapsed")
+				if collapsed {
+					require.Empty(t, diff.Patch, "patch")
+				}
 			}
-		}
+		})
 	}
 }
 
@@ -567,7 +589,8 @@ func TestFailedCommitDiffRequestDueToValidationError(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "d42783470dc29fde2cf459eb3199ee1d7e3f3a72"
 	leftCommit := rightCommit + "~" // Parent of rightCommit
 
@@ -579,15 +602,18 @@ func TestFailedCommitDiffRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
+		t.Run(fmt.Sprintf("%v", rpcRequest), func(t *testing.T) {
 
-		c, err := client.CommitDiff(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitDiff(ctx, &rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		err = drainCommitDiffResponse(c)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+			err = drainCommitDiffResponse(c)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
 
@@ -595,12 +621,15 @@ func TestFailedCommitDiffRequestWithNonExistentCommit(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	nonExistentCommitID := "deadfacedeadfacedeadfacedeadfacedeadface"
 	leftCommit := nonExistentCommitID + "~" // Parent of rightCommit
 	rpcRequest := &pb.CommitDiffRequest{Repository: testRepo, RightCommitId: nonExistentCommitID, LeftCommitId: leftCommit}
 
-	c, err := client.CommitDiff(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDiff(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -613,12 +642,15 @@ func TestSuccessfulCommitDeltaRequest(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "742518b2be68fc750bb4c357c0df821a88113286"
 	leftCommit := "8a0f2ee90d940bfb0ba1e14e8214b0649056e4ab"
 	rpcRequest := &pb.CommitDeltaRequest{Repository: testRepo, RightCommitId: rightCommit, LeftCommitId: leftCommit}
 
-	c, err := client.CommitDelta(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDelta(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -729,7 +761,8 @@ func TestSuccessfulCommitDeltaRequestWithPaths(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "e4003da16c1c2c3fc4567700121b17bf8e591c6c"
 	leftCommit := "8a0f2ee90d940bfb0ba1e14e8214b0649056e4ab"
 	rpcRequest := &pb.CommitDeltaRequest{
@@ -744,7 +777,9 @@ func TestSuccessfulCommitDeltaRequestWithPaths(t *testing.T) {
 		},
 	}
 
-	c, err := client.CommitDelta(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDelta(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -791,7 +826,8 @@ func TestFailedCommitDeltaRequestDueToValidationError(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	rightCommit := "d42783470dc29fde2cf459eb3199ee1d7e3f3a72"
 	leftCommit := rightCommit + "~" // Parent of rightCommit
 
@@ -803,15 +839,18 @@ func TestFailedCommitDeltaRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
+		t.Run(fmt.Sprintf("%v", rpcRequest), func(t *testing.T) {
 
-		c, err := client.CommitDelta(context.Background(), &rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.CommitDelta(ctx, &rpcRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		err = drainCommitDeltaResponse(c)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+			err = drainCommitDeltaResponse(c)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
 
@@ -819,12 +858,15 @@ func TestFailedCommitDeltaRequestWithNonExistentCommit(t *testing.T) {
 	server := runDiffServer(t)
 	defer server.Stop()
 
-	client := newDiffClient(t)
+	client, conn := newDiffClient(t)
+	defer conn.Close()
 	nonExistentCommitID := "deadfacedeadfacedeadfacedeadfacedeadface"
 	leftCommit := nonExistentCommitID + "~" // Parent of rightCommit
 	rpcRequest := &pb.CommitDeltaRequest{Repository: testRepo, RightCommitId: nonExistentCommitID, LeftCommitId: leftCommit}
 
-	c, err := client.CommitDelta(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.CommitDelta(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -834,7 +876,7 @@ func TestFailedCommitDeltaRequestWithNonExistentCommit(t *testing.T) {
 }
 
 func runDiffServer(t *testing.T) *grpc.Server {
-	server := testhelper.NewTestGrpcServer(t)
+	server := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
@@ -848,7 +890,7 @@ func runDiffServer(t *testing.T) *grpc.Server {
 	return server
 }
 
-func newDiffClient(t *testing.T) pb.DiffClient {
+func newDiffClient(t *testing.T) (pb.DiffClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -860,7 +902,7 @@ func newDiffClient(t *testing.T) pb.DiffClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewDiffClient(conn)
+	return pb.NewDiffClient(conn), conn
 }
 
 func drainCommitDiffResponse(c pb.Diff_CommitDiffClient) error {
@@ -870,8 +912,6 @@ func drainCommitDiffResponse(c pb.Diff_CommitDiffClient) error {
 			return err
 		}
 	}
-
-	return nil
 }
 
 func drainCommitDeltaResponse(c pb.Diff_CommitDeltaClient) error {
@@ -881,8 +921,6 @@ func drainCommitDeltaResponse(c pb.Diff_CommitDeltaClient) error {
 			return err
 		}
 	}
-
-	return nil
 }
 
 func getDiffsFromCommitDiffClient(t *testing.T, client pb.DiffService_CommitDiffClient) []*diff.Diff {
diff --git a/internal/service/notifications/post_receive_test.go b/internal/service/notifications/post_receive_test.go
index 57f3d9764..b03f49693 100644
--- a/internal/service/notifications/post_receive_test.go
+++ b/internal/service/notifications/post_receive_test.go
@@ -23,10 +23,13 @@ func TestSuccessfulPostReceive(t *testing.T) {
 	server := runNotificationsServer(t)
 	defer server.Stop()
 
-	client := newNotificationsClient(t)
+	client, conn := newNotificationsClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.PostReceiveRequest{Repository: testRepo}
 
-	_, err := client.PostReceive(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	_, err := client.PostReceive(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -36,15 +39,18 @@ func TestEmptyPostReceiveRequest(t *testing.T) {
 	server := runNotificationsServer(t)
 	defer server.Stop()
 
-	client := newNotificationsClient(t)
+	client, conn := newNotificationsClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.PostReceiveRequest{}
 
-	_, err := client.PostReceive(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	_, err := client.PostReceive(ctx, rpcRequest)
 	testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
 }
 
 func runNotificationsServer(t *testing.T) *grpc.Server {
-	server := testhelper.NewTestGrpcServer(t)
+	server := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
@@ -58,7 +64,7 @@ func runNotificationsServer(t *testing.T) *grpc.Server {
 	return server
 }
 
-func newNotificationsClient(t *testing.T) pb.NotificationsClient {
+func newNotificationsClient(t *testing.T) (pb.NotificationsClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -70,5 +76,5 @@ func newNotificationsClient(t *testing.T) pb.NotificationsClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewNotificationsClient(conn)
+	return pb.NewNotificationsClient(conn), conn
 }
diff --git a/internal/service/ref/refname_test.go b/internal/service/ref/refname_test.go
index c1424499f..5690e1fe6 100644
--- a/internal/service/ref/refname_test.go
+++ b/internal/service/ref/refname_test.go
@@ -15,14 +15,17 @@ func TestFindRefNameSuccess(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindRefNameRequest{
 		Repository: testRepo,
 		CommitId:   "0b4bc9a49b562e85de7cc9e834518ea6828729b9",
 		Prefix:     []byte(`refs/heads/`),
 	}
 
-	c, err := client.FindRefName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindRefName(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -38,14 +41,17 @@ func TestFindRefNameEmptyCommit(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindRefNameRequest{
 		Repository: testRepo,
 		CommitId:   "",
 		Prefix:     []byte(`refs/heads/`),
 	}
 
-	c, err := client.FindRefName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindRefName(ctx, rpcRequest)
 	if err == nil {
 		t.Fatalf("Expected FindRefName to throw an error")
 	}
@@ -63,7 +69,8 @@ func TestFindRefNameInvalidRepo(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 	rpcRequest := &pb.FindRefNameRequest{
 		Repository: repo,
@@ -71,7 +78,9 @@ func TestFindRefNameInvalidRepo(t *testing.T) {
 		Prefix:     []byte(`refs/heads/`),
 	}
 
-	c, err := client.FindRefName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindRefName(ctx, rpcRequest)
 	if err == nil {
 		t.Fatalf("Expected FindRefName to throw an error")
 	}
@@ -89,14 +98,17 @@ func TestFindRefNameInvalidPrefix(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindRefNameRequest{
 		Repository: testRepo,
 		CommitId:   "0b4bc9a49b562e85de7cc9e834518ea6828729b9",
 		Prefix:     []byte(`refs/nonexistant/`),
 	}
 
-	c, err := client.FindRefName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindRefName(ctx, rpcRequest)
 	if err != nil {
 		t.Fatalf("Expected FindRefName to not throw an error: %v", err)
 	}
@@ -109,13 +121,16 @@ func TestFindRefNameInvalidObject(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindRefNameRequest{
 		Repository: testRepo,
 		CommitId:   "dead1234dead1234dead1234dead1234dead1234",
 	}
 
-	c, err := client.FindRefName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindRefName(ctx, rpcRequest)
 	if err != nil {
 		t.Fatalf("Expected FindRefName to not throw an error")
 	}
diff --git a/internal/service/ref/refs_test.go b/internal/service/ref/refs_test.go
index 6bd6a1070..4dd91e6f9 100644
--- a/internal/service/ref/refs_test.go
+++ b/internal/service/ref/refs_test.go
@@ -31,10 +31,13 @@ func TestSuccessfulFindAllBranchNames(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindAllBranchNamesRequest{Repository: testRepo}
 
-	c, err := client.FindAllBranchNames(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllBranchNames(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -61,10 +64,13 @@ func TestEmptyFindAllBranchNamesRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindAllBranchNamesRequest{}
 
-	c, err := client.FindAllBranchNames(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllBranchNames(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -83,11 +89,14 @@ func TestInvalidRepoFindAllBranchNamesRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "default", RelativePath: "made/up/path"}
 	rpcRequest := &pb.FindAllBranchNamesRequest{Repository: repo}
 
-	c, err := client.FindAllBranchNames(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllBranchNames(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -106,10 +115,13 @@ func TestSuccessfulFindAllTagNames(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindAllTagNamesRequest{Repository: testRepo}
 
-	c, err := client.FindAllTagNames(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllTagNames(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -137,10 +149,13 @@ func TestEmptyFindAllTagNamesRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindAllTagNamesRequest{}
 
-	c, err := client.FindAllTagNames(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllTagNames(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -159,11 +174,14 @@ func TestInvalidRepoFindAllTagNamesRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "default", RelativePath: "made/up/path"}
 	rpcRequest := &pb.FindAllTagNamesRequest{Repository: repo}
 
-	c, err := client.FindAllTagNames(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllTagNames(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -179,7 +197,9 @@ func TestInvalidRepoFindAllTagNamesRequest(t *testing.T) {
 }
 
 func TestHeadReference(t *testing.T) {
-	headRef, err := headReference(context.Background(), testRepoPath)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	headRef, err := headReference(ctx, testRepoPath)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -196,7 +216,9 @@ func TestHeadReferenceWithNonExistingHead(t *testing.T) {
 		ioutil.WriteFile(testRepoPath+"/HEAD", []byte("ref: refs/heads/master"), 0644)
 	}()
 
-	headRef, err := headReference(context.Background(), testRepoPath)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	headRef, err := headReference(ctx, testRepoPath)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -262,7 +284,9 @@ func TestDefaultBranchName(t *testing.T) {
 		FindBranchNames = testCase.findBranchNames
 		headReference = testCase.headReference
 
-		defaultBranch, err := DefaultBranchName(context.Background(), "")
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		defaultBranch, err := DefaultBranchName(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -276,10 +300,13 @@ func TestSuccessfulFindDefaultBranchName(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindDefaultBranchNameRequest{Repository: testRepo}
 
-	r, err := client.FindDefaultBranchName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	r, err := client.FindDefaultBranchName(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -293,10 +320,13 @@ func TestEmptyFindDefaultBranchNameRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindDefaultBranchNameRequest{}
 
-	_, err := client.FindDefaultBranchName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	_, err := client.FindDefaultBranchName(ctx, rpcRequest)
 
 	if grpc.Code(err) != codes.InvalidArgument {
 		t.Fatal(err)
@@ -307,11 +337,14 @@ func TestInvalidRepoFindDefaultBranchNameRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "default", RelativePath: "/made/up/path"}
 	rpcRequest := &pb.FindDefaultBranchNameRequest{Repository: repo}
 
-	_, err := client.FindDefaultBranchName(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	_, err := client.FindDefaultBranchName(ctx, rpcRequest)
 
 	if grpc.Code(err) != codes.NotFound {
 		t.Fatal(err)
@@ -351,7 +384,8 @@ func TestSuccessfulFindAllTagsRequest(t *testing.T) {
 		"-c", fmt.Sprintf("user.email=%s", committerEmail),
 		"tag", "v1.4.0", blobID)
 
-	client := newRefServiceClient(t)
+	client, conn := newRefServiceClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindAllTagsRequest{
 		Repository: &pb.Repository{
 			StorageName:  testRepo.StorageName,
@@ -359,7 +393,9 @@ func TestSuccessfulFindAllTagsRequest(t *testing.T) {
 		},
 	}
 
-	c, err := client.FindAllTags(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllTags(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -466,7 +502,8 @@ func TestInvalidFindAllTagsRequest(t *testing.T) {
 	server := runRefServiceServer(t)
 	defer server.Stop()
 
-	client := newRefServiceClient(t)
+	client, conn := newRefServiceClient(t)
+	defer conn.Close()
 	testCases := []struct {
 		desc    string
 		request *pb.FindAllTagsRequest
@@ -487,19 +524,21 @@ func TestInvalidFindAllTagsRequest(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		t.Logf("test case: %v", tc.desc)
-
-		c, err := client.FindAllTags(context.Background(), tc.request)
-		if err != nil {
-			t.Fatal(err)
-		}
+		t.Run(tc.desc, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.FindAllTags(ctx, tc.request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		var recvError error
-		for recvError == nil {
-			_, recvError = c.Recv()
-		}
+			var recvError error
+			for recvError == nil {
+				_, recvError = c.Recv()
+			}
 
-		testhelper.AssertGrpcError(t, recvError, codes.InvalidArgument, "")
+			testhelper.AssertGrpcError(t, recvError, codes.InvalidArgument, "")
+		})
 	}
 }
 
@@ -507,10 +546,13 @@ func TestSuccessfulFindLocalBranches(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindLocalBranchesRequest{Repository: testRepo}
 
-	c, err := client.FindLocalBranches(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindLocalBranches(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -591,33 +633,38 @@ func TestFindLocalBranchesSort(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 
 	for _, testCase := range testCases {
-		rpcRequest := &pb.FindLocalBranchesRequest{Repository: testRepo, SortBy: testCase.sortBy}
-
-		c, err := client.FindLocalBranches(context.Background(), rpcRequest)
-		if err != nil {
-			t.Fatal(err)
-		}
+		t.Run(testCase.desc, func(t *testing.T) {
+			rpcRequest := &pb.FindLocalBranchesRequest{Repository: testRepo, SortBy: testCase.sortBy}
 
-		var branches []string
-		for {
-			r, err := c.Recv()
-			if err == io.EOF {
-				break
-			}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.FindLocalBranches(ctx, rpcRequest)
 			if err != nil {
 				t.Fatal(err)
 			}
-			for _, branch := range r.GetBranches() {
-				branches = append(branches, string(branch.Name))
+
+			var branches []string
+			for {
+				r, err := c.Recv()
+				if err == io.EOF {
+					break
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, branch := range r.GetBranches() {
+					branches = append(branches, string(branch.Name))
+				}
 			}
-		}
 
-		if !isOrderedSubset(testCase.relativeOrder, branches) {
-			t.Fatalf("%s: Expected branches to have relative order %v; got them as %v", testCase.desc, testCase.relativeOrder, branches)
-		}
+			if !isOrderedSubset(testCase.relativeOrder, branches) {
+				t.Fatalf("%s: Expected branches to have relative order %v; got them as %v", testCase.desc, testCase.relativeOrder, branches)
+			}
+		})
 	}
 }
 
@@ -625,10 +672,13 @@ func TestEmptyFindLocalBranchesRequest(t *testing.T) {
 	server := runRefServer(t)
 	defer server.Stop()
 
-	client := newRefClient(t)
+	client, conn := newRefClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.FindLocalBranchesRequest{}
 
-	c, err := client.FindLocalBranches(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindLocalBranches(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -680,8 +730,11 @@ func TestSuccessfulFindAllBranchesRequest(t *testing.T) {
 	defer deleteRemoteBranch(t, testRepoPath, "origin", "fake-remote-branch")
 
 	request := &pb.FindAllBranchesRequest{Repository: testRepo}
-	client := newRefServiceClient(t)
-	c, err := client.FindAllBranches(context.Background(), request)
+	client, conn := newRefServiceClient(t)
+	defer conn.Close()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.FindAllBranches(ctx, request)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -715,7 +768,8 @@ func TestInvalidFindAllBranchesRequest(t *testing.T) {
 	server := runRefServiceServer(t)
 	defer server.Stop()
 
-	client := newRefServiceClient(t)
+	client, conn := newRefServiceClient(t)
+	defer conn.Close()
 	testCases := []struct {
 		description string
 		request     pb.FindAllBranchesRequest
@@ -736,18 +790,21 @@ func TestInvalidFindAllBranchesRequest(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		t.Logf("test case: %v", tc.description)
+		t.Run(tc.description, func(t *testing.T) {
 
-		c, err := client.FindAllBranches(context.Background(), &tc.request)
-		if err != nil {
-			t.Fatal(err)
-		}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.FindAllBranches(ctx, &tc.request)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		var recvError error
-		for recvError == nil {
-			_, recvError = c.Recv()
-		}
+			var recvError error
+			for recvError == nil {
+				_, recvError = c.Recv()
+			}
 
-		testhelper.AssertGrpcError(t, recvError, codes.InvalidArgument, "")
+			testhelper.AssertGrpcError(t, recvError, codes.InvalidArgument, "")
+		})
 	}
 }
diff --git a/internal/service/ref/testhelper_test.go b/internal/service/ref/testhelper_test.go
index 378cbbc93..780ce4c8f 100644
--- a/internal/service/ref/testhelper_test.go
+++ b/internal/service/ref/testhelper_test.go
@@ -91,7 +91,7 @@ func TestMain(m *testing.M) {
 
 func runRefServer(t *testing.T) *grpc.Server {
 	os.Remove(serverSocketPath)
-	grpcServer := testhelper.NewTestGrpcServer(t)
+	grpcServer := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
@@ -107,7 +107,7 @@ func runRefServer(t *testing.T) *grpc.Server {
 
 func runRefServiceServer(t *testing.T) *grpc.Server {
 	os.Remove(serverSocketPath)
-	grpcServer := testhelper.NewTestGrpcServer(t)
+	grpcServer := testhelper.NewTestGrpcServer(t, nil, nil)
 
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
@@ -122,7 +122,7 @@ func runRefServiceServer(t *testing.T) *grpc.Server {
 	return grpcServer
 }
 
-func newRefClient(t *testing.T) pb.RefClient {
+func newRefClient(t *testing.T) (pb.RefClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -134,10 +134,10 @@ func newRefClient(t *testing.T) pb.RefClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewRefClient(conn)
+	return pb.NewRefClient(conn), conn
 }
 
-func newRefServiceClient(t *testing.T) pb.RefServiceClient {
+func newRefServiceClient(t *testing.T) (pb.RefServiceClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -149,7 +149,7 @@ func newRefServiceClient(t *testing.T) pb.RefServiceClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewRefServiceClient(conn)
+	return pb.NewRefServiceClient(conn), conn
 }
 
 func assertContainsLocalBranch(t *testing.T, branches []*pb.FindLocalBranchResponse, branch *pb.FindLocalBranchResponse) {
diff --git a/internal/service/repository/gc_test.go b/internal/service/repository/gc_test.go
index bb5a01194..b0539e7b9 100644
--- a/internal/service/repository/gc_test.go
+++ b/internal/service/repository/gc_test.go
@@ -2,6 +2,7 @@ package repository
 
 import (
 	"context"
+	"fmt"
 	"path"
 	"path/filepath"
 	"testing"
@@ -18,7 +19,8 @@ func TestGarbageCollectSuccess(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		req  *pb.GarbageCollectRequest
@@ -37,31 +39,34 @@ func TestGarbageCollectSuccess(t *testing.T) {
 	packPath := path.Join(testhelper.GitlabTestStoragePath(), testRepo.GetRelativePath(), "objects", "pack")
 
 	for _, test := range tests {
-		// Reset mtime to a long while ago since some filesystems don't have sub-second
-		// precision on `mtime`.
-		// Stamp taken from https://golang.org/pkg/time/#pkg-constants
-		testhelper.MustRunCommand(t, nil, "touch", "-t", testTimeString, packPath)
-		t.Log(test.desc)
-		c, err := client.GarbageCollect(context.Background(), test.req)
-		assert.NoError(t, err)
-		assert.NotNil(t, c)
-
-		// Entire `path`-folder gets updated so this is fine :D
-		assertModTimeAfter(t, testTime, packPath)
-
-		bmPath, err := filepath.Glob(path.Join(packPath, "pack-*.bitmap"))
-		if err != nil {
-			t.Fatalf("Error globbing bitmaps: %v", err)
-		}
-		if test.req.GetCreateBitmap() {
-			if len(bmPath) == 0 {
-				t.Errorf("No bitmaps found")
+		t.Run(test.desc, func(t *testing.T) {
+			// Reset mtime to a long while ago since some filesystems don't have sub-second
+			// precision on `mtime`.
+			// Stamp taken from https://golang.org/pkg/time/#pkg-constants
+			testhelper.MustRunCommand(t, nil, "touch", "-t", testTimeString, packPath)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.GarbageCollect(ctx, test.req)
+			assert.NoError(t, err)
+			assert.NotNil(t, c)
+
+			// Entire `path`-folder gets updated so this is fine :D
+			assertModTimeAfter(t, testTime, packPath)
+
+			bmPath, err := filepath.Glob(path.Join(packPath, "pack-*.bitmap"))
+			if err != nil {
+				t.Fatalf("Error globbing bitmaps: %v", err)
 			}
-		} else {
-			if len(bmPath) != 0 {
-				t.Errorf("Bitmap found: %v", bmPath)
+			if test.req.GetCreateBitmap() {
+				if len(bmPath) == 0 {
+					t.Errorf("No bitmaps found")
+				}
+			} else {
+				if len(bmPath) != 0 {
+					t.Errorf("Bitmap found: %v", bmPath)
+				}
 			}
-		}
+		})
 	}
 }
 
@@ -69,7 +74,8 @@ func TestGarbageCollectFailure(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		repo *pb.Repository
@@ -82,8 +88,12 @@ func TestGarbageCollectFailure(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		_, err := client.GarbageCollect(context.Background(), &pb.GarbageCollectRequest{Repository: test.repo})
-		testhelper.AssertGrpcError(t, err, test.code, "")
+		t.Run(fmt.Sprintf("%v", test.repo), func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.GarbageCollect(ctx, &pb.GarbageCollectRequest{Repository: test.repo})
+			testhelper.AssertGrpcError(t, err, test.code, "")
+		})
 	}
 
 }
diff --git a/internal/service/repository/repack_test.go b/internal/service/repository/repack_test.go
index c4d42809a..df45b7869 100644
--- a/internal/service/repository/repack_test.go
+++ b/internal/service/repository/repack_test.go
@@ -19,7 +19,8 @@ func TestRepackIncrementalSuccess(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	packPath := path.Join(testhelper.GitlabTestStoragePath(), testRepo.GetRelativePath(), "objects", "pack")
 
@@ -28,7 +29,9 @@ func TestRepackIncrementalSuccess(t *testing.T) {
 	// Stamp taken from https://golang.org/pkg/time/#pkg-constants
 	testhelper.MustRunCommand(t, nil, "touch", "-t", testTimeString, path.Join(packPath, "*"))
 	testTime := time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC)
-	c, err := client.RepackIncremental(context.Background(), &pb.RepackIncrementalRequest{Repository: testRepo})
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.RepackIncremental(ctx, &pb.RepackIncrementalRequest{Repository: testRepo})
 	assert.NoError(t, err)
 	assert.NotNil(t, c)
 
@@ -40,7 +43,8 @@ func TestRepackIncrementalFailure(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		repo *pb.Repository
@@ -54,18 +58,21 @@ func TestRepackIncrementalFailure(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		t.Logf("running test: %q", test.desc)
-		_, err := client.RepackIncremental(context.Background(), &pb.RepackIncrementalRequest{Repository: test.repo})
-		testhelper.AssertGrpcError(t, err, test.code, "")
+		t.Run(test.desc, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.RepackIncremental(ctx, &pb.RepackIncrementalRequest{Repository: test.repo})
+			testhelper.AssertGrpcError(t, err, test.code, "")
+		})
 	}
-
 }
 
 func TestRepackFullSuccess(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		req  *pb.RepackFullRequest
@@ -78,31 +85,34 @@ func TestRepackFullSuccess(t *testing.T) {
 	packPath := path.Join(testhelper.GitlabTestStoragePath(), testRepo.GetRelativePath(), "objects", "pack")
 
 	for _, test := range tests {
-		// Reset mtime to a long while ago since some filesystems don't have sub-second
-		// precision on `mtime`.
-		testhelper.MustRunCommand(t, nil, "touch", "-t", testTimeString, packPath)
-		t.Logf("running test: %q", test.desc)
-		testTime := time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC)
-		c, err := client.RepackFull(context.Background(), test.req)
-		assert.NoError(t, err)
-		assert.NotNil(t, c)
-
-		// Entire `path`-folder gets updated so this is fine :D
-		assertModTimeAfter(t, testTime, packPath)
-
-		bmPath, err := filepath.Glob(path.Join(packPath, "pack-*.bitmap"))
-		if err != nil {
-			t.Fatalf("Error globbing bitmaps: %v", err)
-		}
-		if test.req.GetCreateBitmap() {
-			if len(bmPath) == 0 {
-				t.Errorf("No bitmaps found")
+		t.Run(test.desc, func(t *testing.T) {
+			// Reset mtime to a long while ago since some filesystems don't have sub-second
+			// precision on `mtime`.
+			testhelper.MustRunCommand(t, nil, "touch", "-t", testTimeString, packPath)
+			testTime := time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			c, err := client.RepackFull(ctx, test.req)
+			assert.NoError(t, err)
+			assert.NotNil(t, c)
+
+			// Entire `path`-folder gets updated so this is fine :D
+			assertModTimeAfter(t, testTime, packPath)
+
+			bmPath, err := filepath.Glob(path.Join(packPath, "pack-*.bitmap"))
+			if err != nil {
+				t.Fatalf("Error globbing bitmaps: %v", err)
 			}
-		} else {
-			if len(bmPath) != 0 {
-				t.Errorf("Bitmap found: %v", bmPath)
+			if test.req.GetCreateBitmap() {
+				if len(bmPath) == 0 {
+					t.Errorf("No bitmaps found")
+				}
+			} else {
+				if len(bmPath) != 0 {
+					t.Errorf("Bitmap found: %v", bmPath)
+				}
 			}
-		}
+		})
 	}
 }
 
@@ -110,7 +120,8 @@ func TestRepackFullFailure(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		repo *pb.Repository
@@ -124,9 +135,11 @@ func TestRepackFullFailure(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		t.Logf("running test: %q", test.desc)
-		_, err := client.RepackFull(context.Background(), &pb.RepackFullRequest{Repository: test.repo})
-		testhelper.AssertGrpcError(t, err, test.code, "")
+		t.Run(test.desc, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.RepackFull(ctx, &pb.RepackFullRequest{Repository: test.repo})
+			testhelper.AssertGrpcError(t, err, test.code, "")
+		})
 	}
-
 }
diff --git a/internal/service/repository/repository_test.go b/internal/service/repository/repository_test.go
index 87d82a12d..9c45990be 100644
--- a/internal/service/repository/repository_test.go
+++ b/internal/service/repository/repository_test.go
@@ -23,7 +23,8 @@ func TestRepositoryExists(t *testing.T) {
 	require.NoError(t, err, "tempdir")
 	defer os.Remove(storageOtherDir)
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	// Setup storage paths
 	testStorages := []config.Storage{
@@ -104,7 +105,9 @@ func TestRepositoryExists(t *testing.T) {
 
 	for _, tc := range queries {
 		t.Run(tc.desc, func(t *testing.T) {
-			response, err := client.Exists(context.Background(), tc.request)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			response, err := client.Exists(ctx, tc.request)
 
 			require.Equal(t, tc.errorCode, grpc.Code(err))
 
diff --git a/internal/service/repository/size_test.go b/internal/service/repository/size_test.go
index 120f934ca..0385de4a4 100644
--- a/internal/service/repository/size_test.go
+++ b/internal/service/repository/size_test.go
@@ -19,7 +19,8 @@ func TestSuccessfulRepositorySizeRequest(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	storageName := "default"
 	storagePath, found := config.StoragePath(storageName)
@@ -38,7 +39,9 @@ func TestSuccessfulRepositorySizeRequest(t *testing.T) {
 		},
 	}
 
-	response, err := client.RepositorySize(context.Background(), request)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	response, err := client.RepositorySize(ctx, request)
 	require.NoError(t, err)
 	// We can't test for an exact size because it will be different for systems with different sector sizes,
 	// so we settle for anything greater than zero.
@@ -49,7 +52,8 @@ func TestFailedRepositorySizeRequest(t *testing.T) {
 	server := runRepoServer(t)
 	defer server.Stop()
 
-	client := newRepositoryClient(t)
+	client, conn := newRepositoryClient(t)
+	defer conn.Close()
 
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
@@ -61,13 +65,16 @@ func TestFailedRepositorySizeRequest(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		t.Logf("test case: %q", testCase.description)
+		t.Run(testCase.description, func(t *testing.T) {
 
-		request := &pb.RepositorySizeRequest{
-			Repository: testCase.repo,
-		}
+			request := &pb.RepositorySizeRequest{
+				Repository: testCase.repo,
+			}
 
-		_, err := client.RepositorySize(context.Background(), request)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			_, err := client.RepositorySize(ctx, request)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
diff --git a/internal/service/repository/testhelper_test.go b/internal/service/repository/testhelper_test.go
index 561097a77..536645eae 100644
--- a/internal/service/repository/testhelper_test.go
+++ b/internal/service/repository/testhelper_test.go
@@ -22,7 +22,7 @@ var (
 	testRepo         = testhelper.TestRepository()
 )
 
-func newRepositoryClient(t *testing.T) pb.RepositoryServiceClient {
+func newRepositoryClient(t *testing.T) (pb.RepositoryServiceClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -34,11 +34,11 @@ func newRepositoryClient(t *testing.T) pb.RepositoryServiceClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewRepositoryServiceClient(conn)
+	return pb.NewRepositoryServiceClient(conn), conn
 }
 
 func runRepoServer(t *testing.T) *grpc.Server {
-	server := testhelper.NewTestGrpcServer(t)
+	server := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/service/smarthttp/inforefs_test.go b/internal/service/smarthttp/inforefs_test.go
index 162091cac..baa87b5db 100644
--- a/internal/service/smarthttp/inforefs_test.go
+++ b/internal/service/smarthttp/inforefs_test.go
@@ -18,10 +18,13 @@ func TestSuccessfulInfoRefsUploadPack(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.InfoRefsRequest{Repository: testRepo}
 
-	c, err := client.InfoRefsUploadPack(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.InfoRefsUploadPack(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -44,10 +47,13 @@ func TestSuccessfulInfoRefsReceivePack(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.InfoRefsRequest{Repository: testRepo}
 
-	c, err := client.InfoRefsReceivePack(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.InfoRefsReceivePack(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -70,11 +76,14 @@ func TestFailureRepoNotFoundInfoRefsReceivePack(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "default", RelativePath: "testdata/data/another_repo"}
 	rpcRequest := &pb.InfoRefsRequest{Repository: repo}
 
-	c, err := client.InfoRefsReceivePack(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.InfoRefsReceivePack(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -89,10 +98,13 @@ func TestFailureRepoNotSetInfoRefsReceivePack(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 	rpcRequest := &pb.InfoRefsRequest{}
 
-	c, err := client.InfoRefsReceivePack(context.Background(), rpcRequest)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c, err := client.InfoRefsReceivePack(ctx, rpcRequest)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/service/smarthttp/receive_pack_test.go b/internal/service/smarthttp/receive_pack_test.go
index 74573e2de..3dd4b7941 100644
--- a/internal/service/smarthttp/receive_pack_test.go
+++ b/internal/service/smarthttp/receive_pack_test.go
@@ -70,10 +70,13 @@ func TestSuccessfulReceivePackRequest(t *testing.T) {
 	fmt.Fprintf(requestBuffer, "%04x%s%s", len(pkt)+4, pkt, pktFlushStr)
 	requestBuffer.Write(pack)
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "default", RelativePath: remoteRepoRelativePath}
 	rpcRequest := &pb.PostReceivePackRequest{Repository: repo, GlId: "user-123", GlRepository: "project-123"}
-	stream, err := client.PostReceivePack(context.Background())
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	stream, err := client.PostReceivePack(ctx)
 	require.NoError(t, err)
 
 	require.NoError(t, stream.Send(rpcRequest))
@@ -106,7 +109,8 @@ func TestFailedReceivePackRequestDueToValidationError(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 
 	rpcRequests := []pb.PostReceivePackRequest{
 		{Repository: &pb.Repository{StorageName: "fake", RelativePath: "path"}, GlId: "user-123"},                                  // Repository doesn't exist
@@ -116,15 +120,18 @@ func TestFailedReceivePackRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
-		stream, err := client.PostReceivePack(context.Background())
-		require.NoError(t, err)
-
-		require.NoError(t, stream.Send(&rpcRequest))
-		stream.CloseSend()
-
-		err = drainPostReceivePackResponse(stream)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		t.Run(fmt.Sprintf("%v", rpcRequest), func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			stream, err := client.PostReceivePack(ctx)
+			require.NoError(t, err)
+
+			require.NoError(t, stream.Send(&rpcRequest))
+			stream.CloseSend()
+
+			err = drainPostReceivePackResponse(stream)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
 
diff --git a/internal/service/smarthttp/scan_deepen_test.go b/internal/service/smarthttp/scan_deepen_test.go
index 41934514d..e9b6b5015 100644
--- a/internal/service/smarthttp/scan_deepen_test.go
+++ b/internal/service/smarthttp/scan_deepen_test.go
@@ -19,16 +19,17 @@ func TestSuccessfulScanDeepen(t *testing.T) {
 	}
 
 	for _, example := range examples {
-		desc := fmt.Sprintf(".30s", example.input) // guard against printing very long input
-		reader := bytes.NewReader([]byte(example.input))
-		hasDeepen := scanDeepen(reader)
-		if n := reader.Len(); n != 0 {
-			t.Fatalf("scanDeepen %q: expected reader to be drained, found %d bytes left", desc, n)
-		}
+		t.Run(fmt.Sprintf(".30%s", example.input), func(t *testing.T) {
+			reader := bytes.NewReader([]byte(example.input))
+			hasDeepen := scanDeepen(reader)
+			if n := reader.Len(); n != 0 {
+				t.Fatalf("expected reader to be drained, found %d bytes left", n)
+			}
 
-		if hasDeepen != example.output {
-			t.Fatalf("scanDeepen %q: expected %v, got %v", desc, example.output, hasDeepen)
-		}
+			if hasDeepen != example.output {
+				t.Fatalf("expected %v, got %v", example.output, hasDeepen)
+			}
+		})
 	}
 }
 
@@ -40,8 +41,10 @@ func TestFailedScanDeepen(t *testing.T) {
 	}
 
 	for _, example := range examples {
-		if scanDeepen(bytes.NewReader([]byte(example))) == true {
-			t.Fatalf("scanDeepen %q: expected result to be false, got true", example)
-		}
+		t.Run(example, func(t *testing.T) {
+			if scanDeepen(bytes.NewReader([]byte(example))) == true {
+				t.Fatalf("scanDeepen %q: expected result to be false, got true", example)
+			}
+		})
 	}
 }
diff --git a/internal/service/smarthttp/testhelper_test.go b/internal/service/smarthttp/testhelper_test.go
index 495910c3e..49272c64a 100644
--- a/internal/service/smarthttp/testhelper_test.go
+++ b/internal/service/smarthttp/testhelper_test.go
@@ -25,7 +25,7 @@ var (
 )
 
 func runSmartHTTPServer(t *testing.T) *grpc.Server {
-	server := testhelper.NewTestGrpcServer(t)
+	server := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
@@ -39,7 +39,7 @@ func runSmartHTTPServer(t *testing.T) *grpc.Server {
 	return server
 }
 
-func newSmartHTTPClient(t *testing.T) pb.SmartHTTPClient {
+func newSmartHTTPClient(t *testing.T) (pb.SmartHTTPClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -51,7 +51,7 @@ func newSmartHTTPClient(t *testing.T) pb.SmartHTTPClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewSmartHTTPClient(conn)
+	return pb.NewSmartHTTPClient(conn), conn
 }
 
 func newRefServiceClient(t *testing.T) pb.RefServiceClient {
diff --git a/internal/service/smarthttp/upload_pack_test.go b/internal/service/smarthttp/upload_pack_test.go
index a2f777cd4..ea39e6b60 100644
--- a/internal/service/smarthttp/upload_pack_test.go
+++ b/internal/service/smarthttp/upload_pack_test.go
@@ -66,10 +66,13 @@ func TestSuccessfulUploadPackRequest(t *testing.T) {
 	fmt.Fprintf(requestBuffer, "%04x%s%s", len(wantPkt)+4, wantPkt, pktFlushStr)
 	fmt.Fprintf(requestBuffer, "%04x%s%s", len(havePkt)+4, havePkt, pktFlushStr)
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 	repo := &pb.Repository{StorageName: "default", RelativePath: path.Join(remoteRepoRelativePath, ".git")}
 	rpcRequest := &pb.PostUploadPackRequest{Repository: repo}
-	stream, err := client.PostUploadPack(context.Background())
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	stream, err := client.PostUploadPack(ctx)
 	require.NoError(t, err)
 
 	require.NoError(t, stream.Send(rpcRequest))
@@ -107,8 +110,11 @@ func TestSuccessfulUploadPackDeepenRequest(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
-	stream, err := client.PostUploadPack(context.Background())
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	stream, err := client.PostUploadPack(ctx)
 	require.NoError(t, err)
 
 	require.NoError(t, stream.Send(&pb.PostUploadPackRequest{Repository: testRepo}))
@@ -133,7 +139,8 @@ func TestFailedUploadPackRequestDueToValidationError(t *testing.T) {
 	server := runSmartHTTPServer(t)
 	defer server.Stop()
 
-	client := newSmartHTTPClient(t)
+	client, conn := newSmartHTTPClient(t)
+	defer conn.Close()
 
 	rpcRequests := []pb.PostUploadPackRequest{
 		{Repository: &pb.Repository{StorageName: "fake", RelativePath: "path"}}, // Repository doesn't exist
@@ -142,15 +149,18 @@ func TestFailedUploadPackRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, rpcRequest := range rpcRequests {
-		t.Logf("test case: %v", rpcRequest)
-		stream, err := client.PostUploadPack(context.Background())
-		require.NoError(t, err)
-
-		require.NoError(t, stream.Send(&rpcRequest))
-		stream.CloseSend()
-
-		err = drainPostUploadPackResponse(stream)
-		testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		t.Run(fmt.Sprintf("%v", rpcRequest), func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			stream, err := client.PostUploadPack(ctx)
+			require.NoError(t, err)
+
+			require.NoError(t, stream.Send(&rpcRequest))
+			stream.CloseSend()
+
+			err = drainPostUploadPackResponse(stream)
+			testhelper.AssertGrpcError(t, err, codes.InvalidArgument, "")
+		})
 	}
 }
 
diff --git a/internal/service/ssh/receive_pack_test.go b/internal/service/ssh/receive_pack_test.go
index f30c200c5..5cbaad0dc 100644
--- a/internal/service/ssh/receive_pack_test.go
+++ b/internal/service/ssh/receive_pack_test.go
@@ -22,7 +22,8 @@ func TestFailedReceivePackRequestDueToValidationError(t *testing.T) {
 	server := runSSHServer(t)
 	defer server.Stop()
 
-	client := newSSHClient(t)
+	client, conn := newSSHClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		Desc string
@@ -52,19 +53,22 @@ func TestFailedReceivePackRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		t.Logf("test case: %v", test.Desc)
-		stream, err := client.SSHReceivePack(context.Background())
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err = stream.Send(test.Req); err != nil {
-			t.Fatal(err)
-		}
-		stream.CloseSend()
-
-		err = drainPostReceivePackResponse(stream)
-		testhelper.AssertGrpcError(t, err, test.Code, "")
+		t.Run(test.Desc, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			stream, err := client.SSHReceivePack(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if err = stream.Send(test.Req); err != nil {
+				t.Fatal(err)
+			}
+			stream.CloseSend()
+
+			err = drainPostReceivePackResponse(stream)
+			testhelper.AssertGrpcError(t, err, test.Code, "")
+		})
 	}
 }
 
diff --git a/internal/service/ssh/testhelper_test.go b/internal/service/ssh/testhelper_test.go
index 5112e0471..885bf4017 100644
--- a/internal/service/ssh/testhelper_test.go
+++ b/internal/service/ssh/testhelper_test.go
@@ -67,7 +67,7 @@ func mustGetCwd() string {
 }
 
 func runSSHServer(t *testing.T) *grpc.Server {
-	server := testhelper.NewTestGrpcServer(t)
+	server := testhelper.NewTestGrpcServer(t, nil, nil)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
@@ -81,7 +81,7 @@ func runSSHServer(t *testing.T) *grpc.Server {
 	return server
 }
 
-func newSSHClient(t *testing.T) pb.SSHServiceClient {
+func newSSHClient(t *testing.T) (pb.SSHServiceClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
@@ -93,5 +93,5 @@ func newSSHClient(t *testing.T) pb.SSHServiceClient {
 		t.Fatal(err)
 	}
 
-	return pb.NewSSHServiceClient(conn)
+	return pb.NewSSHServiceClient(conn), conn
 }
diff --git a/internal/service/ssh/upload_pack_test.go b/internal/service/ssh/upload_pack_test.go
index 624202ccc..8530c14d4 100644
--- a/internal/service/ssh/upload_pack_test.go
+++ b/internal/service/ssh/upload_pack_test.go
@@ -21,7 +21,8 @@ func TestFailedUploadPackRequestDueToValidationError(t *testing.T) {
 	server := runSSHServer(t)
 	defer server.Stop()
 
-	client := newSSHClient(t)
+	client, conn := newSSHClient(t)
+	defer conn.Close()
 
 	tests := []struct {
 		Desc string
@@ -46,19 +47,22 @@ func TestFailedUploadPackRequestDueToValidationError(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		t.Logf("test case: %s", test.Desc)
-		stream, err := client.SSHUploadPack(context.Background())
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err = stream.Send(test.Req); err != nil {
-			t.Fatal(err)
-		}
-		stream.CloseSend()
-
-		err = drainPostUploadPackResponse(stream)
-		testhelper.AssertGrpcError(t, err, test.Code, "")
+		t.Run(test.Desc, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			stream, err := client.SSHUploadPack(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if err = stream.Send(test.Req); err != nil {
+				t.Fatal(err)
+			}
+			stream.CloseSend()
+
+			err = drainPostUploadPackResponse(stream)
+			testhelper.AssertGrpcError(t, err, test.Code, "")
+		})
 	}
 }
 
diff --git a/internal/testhelper/testhelper.go b/internal/testhelper/testhelper.go
index b0cca04c7..00404ead1 100644
--- a/internal/testhelper/testhelper.go
+++ b/internal/testhelper/testhelper.go
@@ -195,12 +195,14 @@ func ConfigureRuby() {
 }
 
 // NewTestGrpcServer creates a GRPC Server for testing purposes
-func NewTestGrpcServer(t *testing.T) *grpc.Server {
+func NewTestGrpcServer(t *testing.T, streamInterceptors []grpc.StreamServerInterceptor, unaryInterceptors []grpc.UnaryServerInterceptor) *grpc.Server {
 	logger := NewTestLogger(t)
 	logrusEntry := log.NewEntry(logger).WithField("test", t.Name())
 
+	streamInterceptors = append([]grpc.StreamServerInterceptor{grpc_logrus.StreamServerInterceptor(logrusEntry)}, streamInterceptors...)
+	unaryInterceptors = append([]grpc.UnaryServerInterceptor{grpc_logrus.UnaryServerInterceptor(logrusEntry)}, unaryInterceptors...)
 	return grpc.NewServer(
-		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(grpc_logrus.StreamServerInterceptor(logrusEntry))),
-		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(grpc_logrus.UnaryServerInterceptor(logrusEntry))),
+		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(streamInterceptors...)),
+		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(unaryInterceptors...)),
 	)
 }