1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
package repository
import (
"log"
"net"
"os"
"path/filepath"
"testing"
"time"
"github.com/stretchr/testify/assert"
"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
gitalyauth "gitlab.com/gitlab-org/gitaly/auth"
"gitlab.com/gitlab-org/gitaly/internal/config"
"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
"gitlab.com/gitlab-org/gitaly/internal/server/auth"
"gitlab.com/gitlab-org/gitaly/internal/testhelper"
"google.golang.org/grpc"
"google.golang.org/grpc/reflection"
)
// 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)
RubyServer *rubyserver.Server
)
func newRepositoryClient(t *testing.T, serverSocketPath string) (gitalypb.RepositoryServiceClient, *grpc.ClientConn) {
connOpts := []grpc.DialOption{
grpc.WithInsecure(),
grpc.WithPerRPCCredentials(gitalyauth.RPCCredentials(testhelper.RepositoryAuthToken)),
}
conn, err := grpc.Dial(serverSocketPath, connOpts...)
if err != nil {
t.Fatal(err)
}
return gitalypb.NewRepositoryServiceClient(conn), conn
}
var NewRepositoryClient = newRepositoryClient
func runRepoServer(t *testing.T) (*grpc.Server, string) {
streamInt := []grpc.StreamServerInterceptor{auth.StreamServerInterceptor()}
unaryInt := []grpc.UnaryServerInterceptor{auth.UnaryServerInterceptor()}
server := testhelper.NewTestGrpcServer(t, streamInt, unaryInt)
serverSocketPath := testhelper.GetTemporaryGitalySocketFileName()
listener, err := net.Listen("unix", serverSocketPath)
if err != nil {
t.Fatal(err)
}
gitalypb.RegisterRepositoryServiceServer(server, NewServer(RubyServer))
reflection.Register(server)
go server.Serve(listener)
return server, "unix://" + serverSocketPath
}
func assertModTimeAfter(t *testing.T, afterTime time.Time, paths ...string) bool {
// NOTE: Since some filesystems don't have sub-second precision on `mtime`
// we're rounding the times to seconds
afterTime = afterTime.Round(time.Second)
for _, path := range paths {
s, err := os.Stat(path)
assert.NoError(t, err)
if !s.ModTime().Round(time.Second).After(afterTime) {
t.Errorf("ModTime is not after afterTime: %q < %q", s.ModTime().Round(time.Second).String(), afterTime.String())
}
}
return t.Failed()
}
func TestMain(m *testing.M) {
os.Exit(testMain(m))
}
func testMain(m *testing.M) int {
defer testhelper.MustHaveNoChildProcess()
testhelper.ConfigureRuby()
config.Config.Auth = config.Auth{Token: testhelper.RepositoryAuthToken}
var err error
config.Config.GitlabShell.Dir, err = filepath.Abs("testdata/gitlab-shell")
if err != nil {
log.Fatal(err)
}
testhelper.ConfigureGitalySSH()
RubyServer, err = rubyserver.Start()
if err != nil {
log.Fatal(err)
}
defer RubyServer.Stop()
return m.Run()
}
|
