Merge branch 'logging-in-tests' into 'master'

Including logging in tests

See merge request !274

28 files changed, 246 insertions, 167 deletions

diff --git a/Makefile b/Makefile
index 056e2bad6..1a4e9c5f8 100644
--- a/Makefile
+++ b/Makefile
@@ -23,6 +23,8 @@ export PATH := $(GOPATH)/bin:$(PATH)
 # Returns a list of all non-vendored (local packages)
 LOCAL_PACKAGES = $(shell cd "$(PKG_BUILD_DIR)" && GOPATH=$(GOPATH) go list ./... | grep -v '^$(PKG)/vendor/')
 LOCAL_GO_FILES = $(shell find -L $(PKG_BUILD_DIR)  -name "*.go" -not -path "$(PKG_BUILD_DIR)/vendor/*" -not -path "$(PKG_BUILD_DIR)/_build/*")
+CHANGED_LOCAL_GO_FILES = $(shell git status  --porcelain --short | awk '{ print $$2 }' | grep -v '^$(PKG)/vendor/' | grep .go$)
+CHANGED_LOCAL_GO_PACKAGES = $(foreach file,$(CHANGED_LOCAL_GO_FILES),./$(dir $(file))/...)
 COMMAND_PACKAGES = $(shell cd "$(PKG_BUILD_DIR)" && GOPATH=$(GOPATH) go list ./cmd/...)
 COMMANDS = $(subst $(PKG)/cmd/,,$(COMMAND_PACKAGES))
 
@@ -71,6 +73,10 @@ $(TEST_REPO):
 test: $(TARGET_SETUP) $(TEST_REPO) prepare-tests .ruby-bundle
 	@go test $(LOCAL_PACKAGES)
 
+.PHONY: test-changes
+test-changes: $(TARGET_SETUP) $(TEST_REPO) prepare-tests .ruby-bundle
+	cd $(PKG_BUILD_DIR) && go test $(CHANGED_LOCAL_GO_PACKAGES)
+
 .PHONY: prepare-tests
 prepare-tests: $(TARGET_SETUP) $(TEST_REPO)
 
diff --git a/internal/service/blob/get_blob_test.go b/internal/service/blob/get_blob_test.go
index 7ed3ea8d7..c0467629a 100644
--- a/internal/service/blob/get_blob_test.go
+++ b/internal/service/blob/get_blob_test.go
@@ -15,7 +15,10 @@ import (
 )
 
 func TestSuccessfulGetBlob(t *testing.T) {
-	client := newBlobClient(t)
+	server, serverSocketPath := runBlobServer(t)
+	defer server.Stop()
+
+	client := newBlobClient(t, serverSocketPath)
 	maintenanceMdBlobData := testhelper.MustReadFile(t, "testdata/maintenance-md-blob.txt")
 	testCases := []struct {
 		desc     string
@@ -81,7 +84,10 @@ func TestSuccessfulGetBlob(t *testing.T) {
 }
 
 func TestGetBlobNotFound(t *testing.T) {
-	client := newBlobClient(t)
+	server, serverSocketPath := runBlobServer(t)
+	defer server.Stop()
+
+	client := newBlobClient(t, serverSocketPath)
 
 	request := &pb.GetBlobRequest{
 		Repository: testRepo,
@@ -127,7 +133,10 @@ func getBlob(stream pb.BlobService_GetBlobClient) (int64, string, []byte, error)
 }
 
 func TestFailedGetBlobRequestDueToValidationError(t *testing.T) {
-	client := newBlobClient(t)
+	server, serverSocketPath := runBlobServer(t)
+	defer server.Stop()
+
+	client := newBlobClient(t, serverSocketPath)
 	oid := "d42783470dc29fde2cf459eb3199ee1d7e3f3a72"
 
 	rpcRequests := []pb.GetBlobRequest{
diff --git a/internal/service/blob/testhelper_test.go b/internal/service/blob/testhelper_test.go
index 3d4c6bab2..37660be89 100644
--- a/internal/service/blob/testhelper_test.go
+++ b/internal/service/blob/testhelper_test.go
@@ -2,12 +2,9 @@ package blob
 
 import (
 	"net"
-	"os"
 	"testing"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
-
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 
 	"google.golang.org/grpc"
@@ -17,29 +14,16 @@ import (
 )
 
 var (
-	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
-	testRepo         *pb.Repository
-)
-
-func TestMain(m *testing.M) {
 	testRepo = testhelper.TestRepository()
+)
 
-	server := runBlobServer(m)
-	os.Exit(func() int {
-		defer func() {
-			server.Stop()
-			os.Remove(serverSocketPath)
-		}()
-
-		return m.Run()
-	}())
-}
-
-func runBlobServer(m *testing.M) *grpc.Server {
-	server := grpc.NewServer()
+func runBlobServer(t *testing.T) (server *grpc.Server, serverSocketPath string) {
+	server = testhelper.NewTestGrpcServer(t)
+	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
 	listener, err := net.Listen("unix", serverSocketPath)
+
 	if err != nil {
-		log.WithError(err).Fatal("failed to start server")
+		t.Fatal(err)
 	}
 
 	pb.RegisterBlobServiceServer(server, NewServer())
@@ -47,10 +31,10 @@ func runBlobServer(m *testing.M) *grpc.Server {
 
 	go server.Serve(listener)
 
-	return server
+	return
 }
 
-func newBlobClient(t *testing.T) pb.BlobServiceClient {
+func newBlobClient(t *testing.T, serverSocketPath string) pb.BlobServiceClient {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
diff --git a/internal/service/commit/between_test.go b/internal/service/commit/between_test.go
index b5c4f71fc..e260cacd6 100644
--- a/internal/service/commit/between_test.go
+++ b/internal/service/commit/between_test.go
@@ -13,7 +13,10 @@ import (
 )
 
 func TestSuccessfulCommitsBetween(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 	from := []byte("498214de67004b1da3d820901307bed2a68a8ef6") // branch-merged
 	to := []byte("e63f41fe459e62e1228fcef60d7189127aeba95a")   // master
 	fakeHash := []byte("f63f41fe459e62e1228fcef60d7189127aeba95a")
@@ -160,7 +163,11 @@ func TestSuccessfulCommitsBetween(t *testing.T) {
 }
 
 func TestFailedCommitsBetweenRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 	from := []byte("498214de67004b1da3d820901307bed2a68a8ef6")
 	to := []byte("e63f41fe459e62e1228fcef60d7189127aeba95a")
diff --git a/internal/service/commit/commits_by_message_test.go b/internal/service/commit/commits_by_message_test.go
index 88f8731e4..2325fa76a 100644
--- a/internal/service/commit/commits_by_message_test.go
+++ b/internal/service/commit/commits_by_message_test.go
@@ -15,7 +15,10 @@ import (
 )
 
 func TestSuccessfulCommitsByMessageRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	commits := []*pb.GitCommit{
 		{
@@ -142,7 +145,11 @@ func TestSuccessfulCommitsByMessageRequest(t *testing.T) {
 }
 
 func TestFailedCommitsByMessageRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
 	testCases := []struct {
diff --git a/internal/service/commit/count_commits_test.go b/internal/service/commit/count_commits_test.go
index f7cbeb0dd..ae958d41e 100644
--- a/internal/service/commit/count_commits_test.go
+++ b/internal/service/commit/count_commits_test.go
@@ -15,7 +15,10 @@ import (
 )
 
 func TestSuccessfulCountCommitsRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	testCases := []struct {
 		revision, path      []byte
@@ -103,7 +106,11 @@ func TestSuccessfulCountCommitsRequest(t *testing.T) {
 }
 
 func TestFailedCountCommitsRequestDueToValidationError(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	revision := []byte("d42783470dc29fde2cf459eb3199ee1d7e3f3a72")
 
 	rpcRequests := []pb.CountCommitsRequest{
diff --git a/internal/service/commit/find_all_commits_test.go b/internal/service/commit/find_all_commits_test.go
index 2a0cb037e..7de97980f 100644
--- a/internal/service/commit/find_all_commits_test.go
+++ b/internal/service/commit/find_all_commits_test.go
@@ -27,7 +27,10 @@ func TestSuccessfulFindAllCommitsRequest(t *testing.T) {
 		}, nil
 	}
 
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	// Commits made on another branch in parallel to the normal commits below.
 	// Will be used to test topology ordering.
@@ -273,7 +276,11 @@ func TestSuccessfulFindAllCommitsRequest(t *testing.T) {
 }
 
 func TestFailedFindAllCommitsRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
 	testCases := []struct {
diff --git a/internal/service/commit/find_commit_test.go b/internal/service/commit/find_commit_test.go
index 21ca00ab9..019a0efb1 100644
--- a/internal/service/commit/find_commit_test.go
+++ b/internal/service/commit/find_commit_test.go
@@ -11,7 +11,10 @@ import (
 )
 
 func TestSuccessfulFindCommitRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	testCases := []struct {
 		description string
@@ -135,7 +138,10 @@ func TestSuccessfulFindCommitRequest(t *testing.T) {
 }
 
 func TestFailedFindCommitRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
 	testCases := []struct {
diff --git a/internal/service/commit/isancestor_test.go b/internal/service/commit/isancestor_test.go
index b1d0307d1..f41c3d768 100644
--- a/internal/service/commit/isancestor_test.go
+++ b/internal/service/commit/isancestor_test.go
@@ -11,7 +11,10 @@ import (
 )
 
 func TestCommitIsAncestorFailure(t *testing.T) {
-	client := newCommitClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	queries := []struct {
 		Request   *pb.CommitIsAncestorRequest
@@ -66,7 +69,10 @@ func TestCommitIsAncestorFailure(t *testing.T) {
 }
 
 func TestCommitIsAncestorSuccess(t *testing.T) {
-	client := newCommitClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	queries := []struct {
 		Request  *pb.CommitIsAncestorRequest
diff --git a/internal/service/commit/languages_test.go b/internal/service/commit/languages_test.go
index 64814f031..3e68fbbc5 100644
--- a/internal/service/commit/languages_test.go
+++ b/internal/service/commit/languages_test.go
@@ -10,7 +10,10 @@ import (
 )
 
 func TestLanguages(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 	request := &pb.CommitLanguagesRequest{
 		Repository: testRepo,
 		Revision:   []byte("cb19058ecc02d01f8e4290b7e79cafd16a8839b6"),
@@ -53,7 +56,10 @@ func languageEqual(expected, actual *pb.CommitLanguagesResponse_Language) bool {
 }
 
 func TestLanguagesEmptyRevision(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 	request := &pb.CommitLanguagesRequest{
 		Repository: testRepo,
 	}
diff --git a/internal/service/commit/last_commit_for_path_test.go b/internal/service/commit/last_commit_for_path_test.go
index 3a1621aa6..d1e12305c 100644
--- a/internal/service/commit/last_commit_for_path_test.go
+++ b/internal/service/commit/last_commit_for_path_test.go
@@ -14,7 +14,11 @@ import (
 )
 
 func TestSuccessfulLastCommitForPathRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	commit := &pb.GitCommit{
 		Id:      "570e7b2abdd848b95f2f578043fc23bd6f6fd24d",
 		Subject: []byte("Change some files"),
@@ -75,7 +79,11 @@ func TestSuccessfulLastCommitForPathRequest(t *testing.T) {
 }
 
 func TestFailedLastCommitForPathRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
 	testCases := []struct {
diff --git a/internal/service/commit/list_files_test.go b/internal/service/commit/list_files_test.go
index 5db5e8b7a..6a69db952 100644
--- a/internal/service/commit/list_files_test.go
+++ b/internal/service/commit/list_files_test.go
@@ -49,7 +49,11 @@ func TestListFilesSuccess(t *testing.T) {
 		defaultBranchName = ref.DefaultBranchName
 	}()
 
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	tests := []struct {
 		revision string
 		files    [][]byte
@@ -125,7 +129,11 @@ func TestListFilesSuccess(t *testing.T) {
 }
 
 func TestListFilesFailure(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	tests := []struct {
 		repo     *pb.Repository
 		revision string
diff --git a/internal/service/commit/raw_blame_test.go b/internal/service/commit/raw_blame_test.go
index 432219451..4daef297f 100644
--- a/internal/service/commit/raw_blame_test.go
+++ b/internal/service/commit/raw_blame_test.go
@@ -15,7 +15,10 @@ import (
 )
 
 func TestSuccessfulRawBlameRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	testCases := []struct {
 		revision, path, data []byte
@@ -66,7 +69,11 @@ func TestSuccessfulRawBlameRequest(t *testing.T) {
 }
 
 func TestFailedRawBlameRequest(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
 
 	testCases := []struct {
diff --git a/internal/service/commit/stats_test.go b/internal/service/commit/stats_test.go
index 233de90e5..0d8757249 100644
--- a/internal/service/commit/stats_test.go
+++ b/internal/service/commit/stats_test.go
@@ -11,7 +11,10 @@ import (
 )
 
 func TestCommitStatsUnimplemented(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	_, err := client.CommitStats(context.Background(), &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 991df253b..81d6690e2 100644
--- a/internal/service/commit/testhelper_test.go
+++ b/internal/service/commit/testhelper_test.go
@@ -3,13 +3,11 @@ package commit
 import (
 	"bytes"
 	"net"
-	"os"
 	"testing"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
-
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
+	"gitlab.com/gitlab-org/gitaly/internal/supervisor"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 
 	"github.com/golang/protobuf/ptypes/timestamp"
@@ -17,83 +15,54 @@ import (
 	"google.golang.org/grpc/reflection"
 
 	pb "gitlab.com/gitlab-org/gitaly-proto/go"
-	"gitlab.com/gitlab-org/gitaly/internal/service/renameadapter"
 )
 
 var (
-	serverSocketPath  = testhelper.GetTemporaryGitalySocketFileName()
-	serviceSocketPath = testhelper.GetTemporaryGitalySocketFileName()
-	testRepo          *pb.Repository
+	testRepo *pb.Repository
 )
 
-func TestMain(m *testing.M) {
+func startTestServices(t *testing.T) (service *grpc.Server, ruby *supervisor.Process, serverSocketPath string) {
 	testRepo = testhelper.TestRepository()
 
 	testhelper.ConfigureRuby()
 	ruby, err := rubyserver.Start()
 	if err != nil {
-		log.WithError(err).Fatal("ruby spawn failed")
+		t.Fatal("ruby spawn failed")
 	}
 
-	os.Exit(func() int {
-		defer ruby.Stop()
-
-		os.Remove(serverSocketPath)
-		server := runCommitServer(m)
-		defer func() {
-			server.Stop()
-			os.Remove(serverSocketPath)
-		}()
-
-		os.Remove(serviceSocketPath)
-		service := runCommitServiceServer(m)
-		defer func() {
-			service.Stop()
-			os.Remove(serviceSocketPath)
-		}()
-
-		return m.Run()
-	}())
+	service, serverSocketPath = runCommitServiceServer(t)
+	return
 }
 
-func runCommitServer(m *testing.M) *grpc.Server {
-	server := grpc.NewServer()
-	listener, err := net.Listen("unix", serverSocketPath)
-	if err != nil {
-		log.WithError(err).Fatal("failed to start server")
-	}
-
-	pb.RegisterCommitServer(server, renameadapter.NewCommitAdapter(NewServer()))
-	reflection.Register(server)
-
-	go server.Serve(listener)
-
-	return server
+func stopTestServices(service *grpc.Server, ruby *supervisor.Process) {
+	ruby.Stop()
+	service.Stop()
 }
 
-func runCommitServiceServer(m *testing.M) *grpc.Server {
-	server := grpc.NewServer()
+func runCommitServiceServer(t *testing.T) (server *grpc.Server, serviceSocketPath string) {
+	server = grpc.NewServer()
+	serviceSocketPath = testhelper.GetTemporaryGitalySocketFileName()
+
 	listener, err := net.Listen("unix", serviceSocketPath)
 	if err != nil {
-		log.WithError(err).Fatal("failed to start server")
+		t.Fatal("failed to start server")
 	}
 
 	pb.RegisterCommitServiceServer(server, NewServer())
 	reflection.Register(server)
 
 	go server.Serve(listener)
-
-	return server
+	return
 }
 
-func newCommitClient(t *testing.T) pb.CommitClient {
+func newCommitClient(t *testing.T, serviceSocketPath string) pb.CommitClient {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
 			return net.Dial("unix", addr)
 		}),
 	}
-	conn, err := grpc.Dial(serverSocketPath, connOpts...)
+	conn, err := grpc.Dial(serviceSocketPath, connOpts...)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -101,7 +70,7 @@ func newCommitClient(t *testing.T) pb.CommitClient {
 	return pb.NewCommitClient(conn)
 }
 
-func newCommitServiceClient(t *testing.T) pb.CommitServiceClient {
+func newCommitServiceClient(t *testing.T, serviceSocketPath string) pb.CommitServiceClient {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
diff --git a/internal/service/commit/tree_entries_test.go b/internal/service/commit/tree_entries_test.go
index 875479abe..f35cd43c2 100644
--- a/internal/service/commit/tree_entries_test.go
+++ b/internal/service/commit/tree_entries_test.go
@@ -22,7 +22,12 @@ func TestSuccessfulGetTreeEntries(t *testing.T) {
 
 	commitID := "913c66a37b4a45b9769037c55c2d238bd0942d2e"
 	rootOid := "faafbe7fe23fb83c664c78aaded9566c8f934412"
-	client := newCommitServiceClient(t)
+
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	rootEntries := []*pb.TreeEntry{
 		{
 			Oid:       "fd90a3d2d21d6b4f9bec2c33fb7f49780c55f0d2",
@@ -260,7 +265,11 @@ func getTreeEntriesFromTreeEntryClient(t *testing.T, client pb.CommitService_Get
 }
 
 func TestFailedGetTreeEntriesRequestDueToValidationError(t *testing.T) {
-	client := newCommitServiceClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	revision := []byte("d42783470dc29fde2cf459eb3199ee1d7e3f3a72")
 	path := []byte("a/b/c")
 
diff --git a/internal/service/commit/tree_entry.go b/internal/service/commit/tree_entry.go
index 4fdb41142..a2e1d546b 100644
--- a/internal/service/commit/tree_entry.go
+++ b/internal/service/commit/tree_entry.go
@@ -61,7 +61,7 @@ func treeEntryHandler(stream pb.Commit_TreeEntryServer, revision, path, baseName
 			return grpc.Errorf(
 				codes.Internal,
 				"TreeEntry: mismatched object type: tree-oid=%s object-oid=%s entry-type=%s object-type=%s",
-				treeEntry.Oid, objectInfo.Oid, treeEntry.Type.String, objectInfo.Type,
+				treeEntry.Oid, objectInfo.Oid, treeEntry.Type.String(), objectInfo.Type,
 			)
 		}
 
diff --git a/internal/service/commit/tree_entry_test.go b/internal/service/commit/tree_entry_test.go
index 76d8622a9..a15d27896 100644
--- a/internal/service/commit/tree_entry_test.go
+++ b/internal/service/commit/tree_entry_test.go
@@ -22,7 +22,10 @@ type treeEntry struct {
 }
 
 func TestSuccessfulTreeEntry(t *testing.T) {
-	client := newCommitClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
 
 	testCases := []struct {
 		revision          []byte
@@ -137,7 +140,11 @@ func TestSuccessfulTreeEntry(t *testing.T) {
 }
 
 func TestFailedTreeEntryRequestDueToValidationError(t *testing.T) {
-	client := newCommitClient(t)
+	service, ruby, serverSocketPath := startTestServices(t)
+	defer stopTestServices(service, ruby)
+
+	client := newCommitServiceClient(t, serverSocketPath)
+
 	revision := []byte("d42783470dc29fde2cf459eb3199ee1d7e3f3a72")
 	path := []byte("a/b/c")
 
diff --git a/internal/service/diff/commit_test.go b/internal/service/diff/commit_test.go
index f7a7ba5db..10583e8c6 100644
--- a/internal/service/diff/commit_test.go
+++ b/internal/service/diff/commit_test.go
@@ -834,7 +834,7 @@ func TestFailedCommitDeltaRequestWithNonExistentCommit(t *testing.T) {
 }
 
 func runDiffServer(t *testing.T) *grpc.Server {
-	server := grpc.NewServer()
+	server := testhelper.NewTestGrpcServer(t)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/service/diff/testhelper_test.go b/internal/service/diff/testhelper_test.go
index 43ae97ef0..492bddcc3 100644
--- a/internal/service/diff/testhelper_test.go
+++ b/internal/service/diff/testhelper_test.go
@@ -1,20 +1,7 @@
 package diff
 
 import (
-	"os"
-	"testing"
-
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
-
-	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 )
 
-var testRepo *pb.Repository
-
-func TestMain(m *testing.M) {
-	testRepo = testhelper.TestRepository()
-
-	os.Exit(func() int {
-		return m.Run()
-	}())
-}
+var testRepo = testhelper.TestRepository()
diff --git a/internal/service/notifications/post_receive_test.go b/internal/service/notifications/post_receive_test.go
index 797357b0f..57f3d9764 100644
--- a/internal/service/notifications/post_receive_test.go
+++ b/internal/service/notifications/post_receive_test.go
@@ -3,7 +3,6 @@ package notifications
 import (
 	"context"
 	"net"
-	"os"
 	"testing"
 	"time"
 
@@ -17,17 +16,9 @@ import (
 
 var (
 	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
-	testRepo         *pb.Repository
+	testRepo         = testhelper.TestRepository()
 )
 
-func TestMain(m *testing.M) {
-	testRepo = testhelper.TestRepository()
-
-	os.Exit(func() int {
-		return m.Run()
-	}())
-}
-
 func TestSuccessfulPostReceive(t *testing.T) {
 	server := runNotificationsServer(t)
 	defer server.Stop()
@@ -53,7 +44,7 @@ func TestEmptyPostReceiveRequest(t *testing.T) {
 }
 
 func runNotificationsServer(t *testing.T) *grpc.Server {
-	server := grpc.NewServer()
+	server := testhelper.NewTestGrpcServer(t)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/service/ref/testhelper_test.go b/internal/service/ref/testhelper_test.go
index f989cb8fd..378cbbc93 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 := grpc.NewServer()
+	grpcServer := testhelper.NewTestGrpcServer(t)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
@@ -107,7 +107,8 @@ func runRefServer(t *testing.T) *grpc.Server {
 
 func runRefServiceServer(t *testing.T) *grpc.Server {
 	os.Remove(serverSocketPath)
-	grpcServer := grpc.NewServer()
+	grpcServer := testhelper.NewTestGrpcServer(t)
+
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/service/repository/repository_test.go b/internal/service/repository/repository_test.go
index 2b34eb0e3..87d82a12d 100644
--- a/internal/service/repository/repository_test.go
+++ b/internal/service/repository/repository_test.go
@@ -103,16 +103,17 @@ func TestRepositoryExists(t *testing.T) {
 	}
 
 	for _, tc := range queries {
-		t.Log(tc.desc)
-		response, err := client.Exists(context.Background(), tc.request)
+		t.Run(tc.desc, func(t *testing.T) {
+			response, err := client.Exists(context.Background(), tc.request)
 
-		require.Equal(t, tc.errorCode, grpc.Code(err))
+			require.Equal(t, tc.errorCode, grpc.Code(err))
 
-		if err != nil {
-			// Ignore the response message if there was an error
-			continue
-		}
+			if err != nil {
+				// Ignore the response message if there was an error
+				return
+			}
 
-		require.Equal(t, tc.exists, response.Exists)
+			require.Equal(t, tc.exists, response.Exists)
+		})
 	}
 }
diff --git a/internal/service/repository/testhelper_test.go b/internal/service/repository/testhelper_test.go
index a490ae123..561097a77 100644
--- a/internal/service/repository/testhelper_test.go
+++ b/internal/service/repository/testhelper_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
@@ -14,29 +13,15 @@ import (
 	"google.golang.org/grpc/reflection"
 )
 
-const scratchDir = "testdata/scratch"
-
 // Stamp taken from https://golang.org/pkg/time/#pkg-constants
 const testTimeString = "200601021504.05"
 
 var (
 	testTime         = time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)
 	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
-	testRepo         *pb.Repository
+	testRepo         = testhelper.TestRepository()
 )
 
-func TestMain(m *testing.M) {
-	testRepo = testhelper.TestRepository()
-
-	if err := os.MkdirAll(scratchDir, 0755); err != nil {
-		log.WithError(err).Fatal("mkdirall failed")
-	}
-
-	os.Exit(func() int {
-		return m.Run()
-	}())
-}
-
 func newRepositoryClient(t *testing.T) pb.RepositoryServiceClient {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
@@ -53,7 +38,7 @@ func newRepositoryClient(t *testing.T) pb.RepositoryServiceClient {
 }
 
 func runRepoServer(t *testing.T) *grpc.Server {
-	server := grpc.NewServer()
+	server := testhelper.NewTestGrpcServer(t)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/service/smarthttp/testhelper_test.go b/internal/service/smarthttp/testhelper_test.go
index 032b34a8c..495910c3e 100644
--- a/internal/service/smarthttp/testhelper_test.go
+++ b/internal/service/smarthttp/testhelper_test.go
@@ -2,7 +2,6 @@ package smarthttp
 
 import (
 	"net"
-	"os"
 	"testing"
 	"time"
 
@@ -22,19 +21,11 @@ const (
 
 var (
 	serverSocketPath = testhelper.GetTemporaryGitalySocketFileName()
-	testRepo         *pb.Repository
+	testRepo         = testhelper.TestRepository()
 )
 
-func TestMain(m *testing.M) {
-	testRepo = testhelper.TestRepository()
-
-	os.Exit(func() int {
-		return m.Run()
-	}())
-}
-
 func runSmartHTTPServer(t *testing.T) *grpc.Server {
-	server := grpc.NewServer()
+	server := testhelper.NewTestGrpcServer(t)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/service/ssh/testhelper_test.go b/internal/service/ssh/testhelper_test.go
index 9dca3d4e1..5112e0471 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 := grpc.NewServer()
+	server := testhelper.NewTestGrpcServer(t)
 	listener, err := net.Listen("unix", serverSocketPath)
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/testhelper/test_hook.go b/internal/testhelper/test_hook.go
new file mode 100644
index 000000000..458cd771f
--- /dev/null
+++ b/internal/testhelper/test_hook.go
@@ -0,0 +1,54 @@
+package testhelper
+
+import (
+	"io/ioutil"
+	"testing"
+
+	log "github.com/Sirupsen/logrus"
+)
+
+type testHook struct {
+	t         *testing.T
+	formatter log.Formatter
+}
+
+func (s testHook) Levels() []log.Level {
+	return []log.Level{
+		log.DebugLevel,
+		log.InfoLevel,
+		log.WarnLevel,
+		log.ErrorLevel,
+		log.FatalLevel,
+		log.PanicLevel,
+	}
+}
+
+func (s testHook) Fire(entry *log.Entry) error {
+	formatted, err := s.formatter.Format(entry)
+	if err != nil {
+		return err
+	}
+
+	formattedString := string(formatted)
+
+	switch entry.Level {
+	case log.FatalLevel, log.PanicLevel:
+		s.t.Fatal(formattedString)
+
+	default:
+		s.t.Log(formattedString)
+	}
+
+	return nil
+}
+
+// NewTestLogger created a logrus hook which can be used with testing logs
+func NewTestLogger(t *testing.T) *log.Logger {
+	logger := log.New()
+	logger.Out = ioutil.Discard
+	formatter := &log.TextFormatter{}
+
+	logger.Hooks.Add(testHook{t, formatter})
+
+	return logger
+}
diff --git a/internal/testhelper/testhelper.go b/internal/testhelper/testhelper.go
index 869aee43d..b0cca04c7 100644
--- a/internal/testhelper/testhelper.go
+++ b/internal/testhelper/testhelper.go
@@ -15,6 +15,8 @@ import (
 
 	log "github.com/Sirupsen/logrus"
 
+	"github.com/grpc-ecosystem/go-grpc-middleware"
+	"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus"
 	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 	"gitlab.com/gitlab-org/gitaly/internal/config"
 
@@ -191,3 +193,14 @@ func ConfigureRuby() {
 	}
 	config.Config.Ruby.Dir = path.Join(path.Dir(currentFile), "../../ruby")
 }
+
+// NewTestGrpcServer creates a GRPC Server for testing purposes
+func NewTestGrpcServer(t *testing.T) *grpc.Server {
+	logger := NewTestLogger(t)
+	logrusEntry := log.NewEntry(logger).WithField("test", t.Name())
+
+	return grpc.NewServer(
+		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(grpc_logrus.StreamServerInterceptor(logrusEntry))),
+		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(grpc_logrus.UnaryServerInterceptor(logrusEntry))),
+	)
+}