Merge branch '6263-gitolite-test' refs #6263

diff --git a/services/arv-git-httpd/gitolite_test.go b/services/arv-git-httpd/gitolite_test.go
new file mode 100644 (file)
index 0000000..8458730
--- /dev/null
+++ b/services/arv-git-httpd/gitolite_test.go
@@ -0,0 +1,93 @@
+package main
+
+import (
+       "os"
+       "os/exec"
+       "io/ioutil"
+
+       check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&GitoliteSuite{})
+
+// GitoliteSuite tests need an API server, an arv-git-httpd server,
+// and a repository hosted by gitolite.
+type GitoliteSuite struct {
+       IntegrationSuite
+       gitoliteHome string
+}
+
+func (s *GitoliteSuite) SetUpTest(c *check.C) {
+       var err error
+       s.gitoliteHome, err = ioutil.TempDir("", "arv-git-httpd")
+       c.Assert(err, check.Equals, nil)
+
+       runGitolite := func(prog string, args ...string) {
+               c.Log(prog, " ", args)
+               cmd := exec.Command(prog, args...)
+               cmd.Dir = s.gitoliteHome
+               cmd.Env = append(os.Environ(), "HOME=" + s.gitoliteHome)
+               diags, err := cmd.CombinedOutput()
+               c.Log(string(diags))
+               c.Assert(err, check.Equals, nil)
+       }
+
+       runGitolite("gitolite", "setup", "--admin", "root")
+
+       s.tmpRepoRoot = s.gitoliteHome + "/repositories"
+       s.Config = &config{
+               Addr:       ":0",
+               GitCommand: "/usr/share/gitolite3/gitolite-shell",
+               Root:       s.tmpRepoRoot,
+       }
+       s.IntegrationSuite.SetUpTest(c)
+
+       // Install the gitolite hooks in the bare repo we made in
+       // (*IntegrationTest)SetUpTest() -- see 2.2.4 at
+       // http://gitolite.com/gitolite/gitolite.html
+       runGitolite("gitolite", "setup")
+
+       os.Setenv("GITOLITE_HTTP_HOME", s.gitoliteHome)
+       os.Setenv("GL_BYPASS_ACCESS_CHECKS", "1")
+}
+
+func (s *GitoliteSuite) TearDownTest(c *check.C) {
+       // We really want Unsetenv here, but it's not worth forcing an
+       // upgrade to Go 1.4.
+       os.Setenv("GITOLITE_HTTP_HOME", "")
+       os.Setenv("GL_BYPASS_ACCESS_CHECKS", "")
+       s.IntegrationSuite.TearDownTest(c)
+}
+
+func (s *GitoliteSuite) TestFetch(c *check.C) {
+       err := s.RunGit(c, activeToken, "fetch", "active/foo.git")
+       c.Check(err, check.Equals, nil)
+}
+
+func (s *GitoliteSuite) TestFetchUnreadable(c *check.C) {
+       err := s.RunGit(c, anonymousToken, "fetch", "active/foo.git")
+       c.Check(err, check.ErrorMatches, `.* not found.*`)
+}
+
+func (s *GitoliteSuite) TestPush(c *check.C) {
+       err := s.RunGit(c, activeToken, "push", "active/foo.git")
+       c.Check(err, check.Equals, nil)
+
+       // Check that the commit hash appears in the gitolite log, as
+       // assurance that the gitolite hooks really did run.
+
+       sha1, err := exec.Command("git", "--git-dir", s.tmpWorkdir + "/.git",
+               "log", "-n1", "--format=%H").CombinedOutput()
+       c.Logf("git-log in workdir: %q", string(sha1))
+       c.Assert(err, check.Equals, nil)
+       c.Assert(len(sha1), check.Equals, 41)
+
+       gitoliteLog, err := exec.Command("grep", "-r", string(sha1[:40]), s.gitoliteHome + "/.gitolite/logs").CombinedOutput()
+       c.Check(err, check.Equals, nil)
+       c.Logf("gitolite log message: %q", string(gitoliteLog))
+}
+
+func (s *GitoliteSuite) TestPushUnwritable(c *check.C) {
+       err := s.RunGit(c, spectatorToken, "push", "active/foo.git")
+       c.Check(err, check.ErrorMatches, `.*HTTP code = 403.*`)
+}

diff --git a/services/arv-git-httpd/integration_test.go b/services/arv-git-httpd/integration_test.go
new file mode 100644 (file)
index 0000000..61d83ff
--- /dev/null
+++ b/services/arv-git-httpd/integration_test.go
@@ -0,0 +1,133 @@
+package main
+
+import (
+       "errors"
+       "io/ioutil"
+       "os"
+       "os/exec"
+       "strings"
+       "testing"
+
+       "git.curoverse.com/arvados.git/sdk/go/arvadostest"
+       check "gopkg.in/check.v1"
+)
+
+// Gocheck boilerplate
+func Test(t *testing.T) {
+       check.TestingT(t)
+}
+
+// IntegrationSuite tests need an API server and an arv-git-httpd
+// server. See GitSuite and GitoliteSuite.
+type IntegrationSuite struct {
+       tmpRepoRoot string
+       tmpWorkdir  string
+       testServer  *server
+       Config      *config
+}
+
+func (s *IntegrationSuite) SetUpSuite(c *check.C) {
+       arvadostest.StartAPI()
+}
+
+func (s *IntegrationSuite) TearDownSuite(c *check.C) {
+       arvadostest.StopAPI()
+}
+
+func (s *IntegrationSuite) SetUpTest(c *check.C) {
+       arvadostest.ResetEnv()
+       s.testServer = &server{}
+       var err error
+       if s.tmpRepoRoot == "" {
+               s.tmpRepoRoot, err = ioutil.TempDir("", "arv-git-httpd")
+               c.Assert(err, check.Equals, nil)
+       }
+       s.tmpWorkdir, err = ioutil.TempDir("", "arv-git-httpd")
+       c.Assert(err, check.Equals, nil)
+       _, err = exec.Command("git", "init", "--bare", s.tmpRepoRoot+"/zzzzz-s0uqq-382brsig8rp3666.git").Output()
+       c.Assert(err, check.Equals, nil)
+       _, err = exec.Command("git", "init", s.tmpWorkdir).Output()
+       c.Assert(err, check.Equals, nil)
+       _, err = exec.Command("sh", "-c", "cd "+s.tmpWorkdir+" && echo initial >initial && git add initial && git -c user.name=Initial -c user.email=Initial commit -am 'foo: initial commit'").CombinedOutput()
+       c.Assert(err, check.Equals, nil)
+       _, err = exec.Command("sh", "-c", "cd "+s.tmpWorkdir+" && git push "+s.tmpRepoRoot+"/zzzzz-s0uqq-382brsig8rp3666.git master:master").CombinedOutput()
+       c.Assert(err, check.Equals, nil)
+       _, err = exec.Command("sh", "-c", "cd "+s.tmpWorkdir+" && echo work >work && git add work && git -c user.name=Foo -c user.email=Foo commit -am 'workdir: test'").CombinedOutput()
+       c.Assert(err, check.Equals, nil)
+
+       _, err = exec.Command("git", "config",
+               "--file", s.tmpWorkdir+"/.git/config",
+               "credential.http://"+s.testServer.Addr+"/.helper",
+               "!cred(){ cat >/dev/null; if [ \"$1\" = get ]; then echo password=$ARVADOS_API_TOKEN; fi; };cred").Output()
+       c.Assert(err, check.Equals, nil)
+       _, err = exec.Command("git", "config",
+               "--file", s.tmpWorkdir+"/.git/config",
+               "credential.http://"+s.testServer.Addr+"/.username",
+               "none").Output()
+       c.Assert(err, check.Equals, nil)
+
+       if s.Config == nil {
+               s.Config = &config{
+                       Addr:       ":0",
+                       GitCommand: "/usr/bin/git",
+                       Root:       s.tmpRepoRoot,
+               }
+       }
+       theConfig = s.Config
+       err = s.testServer.Start()
+       c.Assert(err, check.Equals, nil)
+
+       // Clear ARVADOS_API_TOKEN after starting up the server, to
+       // make sure arv-git-httpd doesn't use it.
+       os.Setenv("ARVADOS_API_TOKEN", "unused-token-placates-client-library")
+}
+
+func (s *IntegrationSuite) TearDownTest(c *check.C) {
+       var err error
+       if s.testServer != nil {
+               err = s.testServer.Close()
+       }
+       c.Check(err, check.Equals, nil)
+       s.testServer = nil
+
+       if s.tmpRepoRoot != "" {
+               err = os.RemoveAll(s.tmpRepoRoot)
+               c.Check(err, check.Equals, nil)
+       }
+       s.tmpRepoRoot = ""
+
+       if s.tmpWorkdir != "" {
+               err = os.RemoveAll(s.tmpWorkdir)
+               c.Check(err, check.Equals, nil)
+       }
+       s.tmpWorkdir = ""
+
+       s.Config = nil
+}
+
+func (s *IntegrationSuite) RunGit(c *check.C, token, gitCmd, repo string, args ...string) error {
+       cwd, err := os.Getwd()
+       c.Assert(err, check.Equals, nil)
+       defer os.Chdir(cwd)
+       os.Chdir(s.tmpWorkdir)
+
+       gitargs := append([]string{
+               gitCmd, "http://" + s.testServer.Addr + "/" + repo,
+       }, args...)
+       cmd := exec.Command("git", gitargs...)
+       cmd.Env = append(os.Environ(), "ARVADOS_API_TOKEN="+token)
+       w, err := cmd.StdinPipe()
+       c.Assert(err, check.Equals, nil)
+       w.Close()
+       output, err := cmd.CombinedOutput()
+       c.Log("git ", gitargs, " => ", err)
+       c.Log(string(output))
+       if err != nil && len(output) > 0 {
+               // If messages appeared on stderr, they are more
+               // helpful than the err returned by CombinedOutput().
+               //
+               // Easier to match error strings without newlines:
+               err = errors.New(strings.Replace(string(output), "\n", " // ", -1))
+       }
+       return err
+}

diff --git a/services/arv-git-httpd/server_test.go b/services/arv-git-httpd/server_test.go
index c1364ca75b22ce18a72c74ffadf9667a69bf1225..2d1aeb78491df27c9f85d3cbe612218038b6c39c 100644 (file)
--- a/services/arv-git-httpd/server_test.go
+++ b/services/arv-git-httpd/server_test.go
@@ -1,18 +1,13 @@
 package main
 
 import (
-       "errors"
-       "io/ioutil"
        "os"
        "os/exec"
-       "strings"
-       "testing"
 
-       "git.curoverse.com/arvados.git/sdk/go/arvadostest"
        check "gopkg.in/check.v1"
 )
 
-var _ = check.Suite(&IntegrationSuite{})
+var _ = check.Suite(&GitSuite{})
 
 const (
        spectatorToken = "zw2f4gwx8hw8cjre7yp6v1zylhrhn3m5gvjq73rtpwhmknrybu"
@@ -21,178 +16,83 @@ const (
        expiredToken   = "2ym314ysp27sk7h943q6vtc378srb06se3pq6ghurylyf3pdmx"
 )
 
-// IntegrationSuite tests need an API server and an arv-git-httpd server
-type IntegrationSuite struct {
-       tmpRepoRoot string
-       tmpWorkdir  string
-       testServer  *server
+type GitSuite struct {
+       IntegrationSuite
 }
 
-func (s *IntegrationSuite) TestPathVariants(c *check.C) {
+func (s *GitSuite) TestPathVariants(c *check.C) {
        s.makeArvadosRepo(c)
        for _, repo := range []string{"active/foo.git", "active/foo/.git", "arvados.git", "arvados/.git"} {
-               err := s.runGit(c, spectatorToken, "fetch", repo)
+               err := s.RunGit(c, spectatorToken, "fetch", repo)
                c.Assert(err, check.Equals, nil)
        }
 }
 
-func (s *IntegrationSuite) TestReadonly(c *check.C) {
-       err := s.runGit(c, spectatorToken, "fetch", "active/foo.git")
+func (s *GitSuite) TestReadonly(c *check.C) {
+       err := s.RunGit(c, spectatorToken, "fetch", "active/foo.git")
        c.Assert(err, check.Equals, nil)
-       err = s.runGit(c, spectatorToken, "push", "active/foo.git", "master:newbranchfail")
+       err = s.RunGit(c, spectatorToken, "push", "active/foo.git", "master:newbranchfail")
        c.Assert(err, check.ErrorMatches, `.*HTTP code = 403.*`)
-       _, err = os.Stat(s.tmpRepoRoot + "/zzzzz-s0uqq-382brsig8rp3666/.git/refs/heads/newbranchfail")
+       _, err = os.Stat(s.tmpRepoRoot + "/zzzzz-s0uqq-382brsig8rp3666.git/refs/heads/newbranchfail")
        c.Assert(err, check.FitsTypeOf, &os.PathError{})
 }
 
-func (s *IntegrationSuite) TestReadwrite(c *check.C) {
-       err := s.runGit(c, activeToken, "fetch", "active/foo.git")
+func (s *GitSuite) TestReadwrite(c *check.C) {
+       err := s.RunGit(c, activeToken, "fetch", "active/foo.git")
        c.Assert(err, check.Equals, nil)
-       err = s.runGit(c, activeToken, "push", "active/foo.git", "master:newbranch")
+       err = s.RunGit(c, activeToken, "push", "active/foo.git", "master:newbranch")
        c.Assert(err, check.Equals, nil)
-       _, err = os.Stat(s.tmpRepoRoot + "/zzzzz-s0uqq-382brsig8rp3666/.git/refs/heads/newbranch")
+       _, err = os.Stat(s.tmpRepoRoot + "/zzzzz-s0uqq-382brsig8rp3666.git/refs/heads/newbranch")
        c.Assert(err, check.Equals, nil)
 }
 
-func (s *IntegrationSuite) TestNonexistent(c *check.C) {
-       err := s.runGit(c, spectatorToken, "fetch", "thisrepodoesnotexist.git")
+func (s *GitSuite) TestNonexistent(c *check.C) {
+       err := s.RunGit(c, spectatorToken, "fetch", "thisrepodoesnotexist.git")
        c.Assert(err, check.ErrorMatches, `.* not found.*`)
 }
 
-func (s *IntegrationSuite) TestMissingGitdirReadableRepository(c *check.C) {
-       err := s.runGit(c, activeToken, "fetch", "active/foo2.git")
+func (s *GitSuite) TestMissingGitdirReadableRepository(c *check.C) {
+       err := s.RunGit(c, activeToken, "fetch", "active/foo2.git")
        c.Assert(err, check.ErrorMatches, `.* not found.*`)
 }
 
-func (s *IntegrationSuite) TestNoPermission(c *check.C) {
+func (s *GitSuite) TestNoPermission(c *check.C) {
        for _, repo := range []string{"active/foo.git", "active/foo/.git"} {
-               err := s.runGit(c, anonymousToken, "fetch", repo)
+               err := s.RunGit(c, anonymousToken, "fetch", repo)
                c.Assert(err, check.ErrorMatches, `.* not found.*`)
        }
 }
 
-func (s *IntegrationSuite) TestExpiredToken(c *check.C) {
+func (s *GitSuite) TestExpiredToken(c *check.C) {
        for _, repo := range []string{"active/foo.git", "active/foo/.git"} {
-               err := s.runGit(c, expiredToken, "fetch", repo)
+               err := s.RunGit(c, expiredToken, "fetch", repo)
                c.Assert(err, check.ErrorMatches, `.* 500 while accessing.*`)
        }
 }
 
-func (s *IntegrationSuite) TestInvalidToken(c *check.C) {
+func (s *GitSuite) TestInvalidToken(c *check.C) {
        for _, repo := range []string{"active/foo.git", "active/foo/.git"} {
-               err := s.runGit(c, "s3cr3tp@ssw0rd", "fetch", repo)
+               err := s.RunGit(c, "s3cr3tp@ssw0rd", "fetch", repo)
                c.Assert(err, check.ErrorMatches, `.* requested URL returned error.*`)
        }
 }
 
-func (s *IntegrationSuite) TestShortToken(c *check.C) {
+func (s *GitSuite) TestShortToken(c *check.C) {
        for _, repo := range []string{"active/foo.git", "active/foo/.git"} {
-               err := s.runGit(c, "s3cr3t", "fetch", repo)
+               err := s.RunGit(c, "s3cr3t", "fetch", repo)
                c.Assert(err, check.ErrorMatches, `.* 500 while accessing.*`)
        }
 }
 
-func (s *IntegrationSuite) TestShortTokenBadReq(c *check.C) {
+func (s *GitSuite) TestShortTokenBadReq(c *check.C) {
        for _, repo := range []string{"bogus"} {
-               err := s.runGit(c, "s3cr3t", "fetch", repo)
+               err := s.RunGit(c, "s3cr3t", "fetch", repo)
                c.Assert(err, check.ErrorMatches, `.* requested URL returned error.*`)
        }
 }
 
-func (s *IntegrationSuite) SetUpSuite(c *check.C) {
-       arvadostest.StartAPI()
-}
-
-func (s *IntegrationSuite) TearDownSuite(c *check.C) {
-       arvadostest.StopAPI()
-}
-
-func (s *IntegrationSuite) SetUpTest(c *check.C) {
-       arvadostest.ResetEnv()
-       s.testServer = &server{}
-       var err error
-       s.tmpRepoRoot, err = ioutil.TempDir("", "arv-git-httpd")
-       c.Assert(err, check.Equals, nil)
-       s.tmpWorkdir, err = ioutil.TempDir("", "arv-git-httpd")
-       c.Assert(err, check.Equals, nil)
-       _, err = exec.Command("git", "init", s.tmpRepoRoot+"/zzzzz-s0uqq-382brsig8rp3666").Output()
-       c.Assert(err, check.Equals, nil)
-       _, err = exec.Command("sh", "-c", "cd "+s.tmpRepoRoot+"/zzzzz-s0uqq-382brsig8rp3666 && echo test >test && git add test && git -c user.name=Foo -c user.email=Foo commit -am 'foo: test'").CombinedOutput()
-       c.Assert(err, check.Equals, nil)
-       _, err = exec.Command("git", "init", s.tmpWorkdir).Output()
-       c.Assert(err, check.Equals, nil)
-       _, err = exec.Command("sh", "-c", "cd "+s.tmpWorkdir+" && echo work >work && git add work && git -c user.name=Foo -c user.email=Foo commit -am 'workdir: test'").CombinedOutput()
-       c.Assert(err, check.Equals, nil)
-
-       _, err = exec.Command("git", "config",
-               "--file", s.tmpWorkdir+"/.git/config",
-               "credential.http://"+s.testServer.Addr+"/.helper",
-               "!cred(){ cat >/dev/null; if [ \"$1\" = get ]; then echo password=$ARVADOS_API_TOKEN; fi; };cred").Output()
-       c.Assert(err, check.Equals, nil)
-       _, err = exec.Command("git", "config",
-               "--file", s.tmpWorkdir+"/.git/config",
-               "credential.http://"+s.testServer.Addr+"/.username",
-               "none").Output()
-       c.Assert(err, check.Equals, nil)
-
-       theConfig = &config{
-               Addr:       ":0",
-               GitCommand: "/usr/bin/git",
-               Root:       s.tmpRepoRoot,
-       }
-       err = s.testServer.Start()
-       c.Assert(err, check.Equals, nil)
-
-       // Clear ARVADOS_API_TOKEN after starting up the server, to
-       // make sure arv-git-httpd doesn't use it.
-       os.Setenv("ARVADOS_API_TOKEN", "unused-token-placates-client-library")
-}
-
-func (s *IntegrationSuite) TearDownTest(c *check.C) {
-       var err error
-       if s.testServer != nil {
-               err = s.testServer.Close()
-       }
-       c.Check(err, check.Equals, nil)
-       if s.tmpRepoRoot != "" {
-               err = os.RemoveAll(s.tmpRepoRoot)
-               c.Check(err, check.Equals, nil)
-       }
-       if s.tmpWorkdir != "" {
-               err = os.RemoveAll(s.tmpWorkdir)
-               c.Check(err, check.Equals, nil)
-       }
-}
-
-func (s *IntegrationSuite) runGit(c *check.C, token, gitCmd, repo string, args ...string) error {
-       cwd, err := os.Getwd()
-       c.Assert(err, check.Equals, nil)
-       defer os.Chdir(cwd)
-       os.Chdir(s.tmpWorkdir)
-
-       gitargs := append([]string{
-               gitCmd, "http://" + s.testServer.Addr + "/" + repo,
-       }, args...)
-       cmd := exec.Command("git", gitargs...)
-       cmd.Env = append(os.Environ(), "ARVADOS_API_TOKEN="+token)
-       w, err := cmd.StdinPipe()
-       c.Assert(err, check.Equals, nil)
-       w.Close()
-       output, err := cmd.CombinedOutput()
-       c.Log("git ", gitargs, " => ", err)
-       c.Log(string(output))
-       if err != nil && len(output) > 0 {
-               // If messages appeared on stderr, they are more
-               // helpful than the err returned by CombinedOutput().
-               //
-               // Easier to match error strings without newlines:
-               err = errors.New(strings.Replace(string(output), "\n", " // ", -1))
-       }
-       return err
-}
-
 // Make a bare arvados repo at {tmpRepoRoot}/arvados.git
-func (s *IntegrationSuite) makeArvadosRepo(c *check.C) {
+func (s *GitSuite) makeArvadosRepo(c *check.C) {
        msg, err := exec.Command("git", "init", "--bare", s.tmpRepoRoot+"/zzzzz-s0uqq-arvadosrepo0123.git").CombinedOutput()
        c.Log(string(msg))
        c.Assert(err, check.Equals, nil)
@@ -200,8 +100,3 @@ func (s *IntegrationSuite) makeArvadosRepo(c *check.C) {
        c.Log(string(msg))
        c.Assert(err, check.Equals, nil)
 }
-
-// Gocheck boilerplate
-func Test(t *testing.T) {
-       check.TestingT(t)
-}