package ssh
import (
"fmt"
"io/ioutil"
"net"
"os"
"golang.org/x/crypto/ssh/agent"
. "gopkg.in/check.v1"
"gopkg.in/src-d/go-git.v2/clients/common"
"gopkg.in/src-d/go-git.v2/core"
)
type SuiteRemote struct{}
var _ = Suite(&SuiteRemote{})
const (
fixRepo = "git@github.com:tyba/git-fixture.git"
fixRepoBadVcs = "www.example.com"
fixRepoNonGit = "https://code.google.com/p/go"
fixGitRepoNonGithub = "https://bitbucket.org/user/repo.git"
)
func (s *SuiteRemote) TestConnect(c *C) {
fmt.Println("TestConnect")
r := NewGitUploadPackService()
c.Assert(r.Connect(fixRepo), Equals, ErrAuthRequired)
}
// We will use a running ssh agent for testing
// ssh authentication.
type sshAgentConn struct {
pipe net.Conn
auth *PublicKeysCallback
}
// Opens a pipe with the ssh agent and uses the pipe
// as the implementer of the public key callback function.
func newSSHAgentConn() (*sshAgentConn, error) {
pipe, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
if err != nil {
return nil, err
}
return &sshAgentConn{
pipe: pipe,
auth: &PublicKeysCallback{
User: "git",
Callback: agent.NewClient(pipe).Signers,
},
}, nil
}
// Closes the pipe with the ssh agent
func (c *sshAgentConn) close() error {
return c.pipe.Close()
}
func (s *SuiteRemote) TestConnectWithPublicKeysCallback(c *C) {
fmt.Println("TestConnectWithPublicKeysCallback")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
defer func() { c.Assert(r.Disconnect(), IsNil) }()
c.Assert(r.connected, Equals, true)
c.Assert(r.auth, Equals, agent.auth)
}
func (s *SuiteRemote) TestConnectBadVcs(c *C) {
fmt.Println("TestConnectBadVcs")
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepoBadVcs, nil), ErrorMatches, fmt.Sprintf(".*%s.*", fixRepoBadVcs))
}
func (s *SuiteRemote) TestConnectNonGit(c *C) {
fmt.Println("TestConnectNonGit")
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepoNonGit, nil), Equals, ErrUnsupportedVCS)
}
func (s *SuiteRemote) TestConnectNonGithub(c *C) {
fmt.Println("TestConnectNonGit")
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixGitRepoNonGithub, nil), Equals, ErrUnsupportedRepo)
}
// A mock implementation of client.common.AuthMethod
// to test non ssh auth method detection.
type mockAuth struct{}
func (*mockAuth) Name() string { return "" }
func (*mockAuth) String() string { return "" }
func (s *SuiteRemote) TestConnectWithAuthWrongType(c *C) {
fmt.Println("TestConnectWithAuthWrongType")
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, &mockAuth{}), Equals, ErrInvalidAuthMethod)
c.Assert(r.connected, Equals, false)
}
func (s *SuiteRemote) TestAlreadyConnected(c *C) {
fmt.Println("TestAlreadyConnected")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
defer func() { c.Assert(r.Disconnect(), IsNil) }()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), Equals, ErrAlreadyConnected)
c.Assert(r.connected, Equals, true)
}
func (s *SuiteRemote) TestDisconnect(c *C) {
fmt.Println("TestDisconnect")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
c.Assert(r.Disconnect(), IsNil)
c.Assert(r.connected, Equals, false)
}
func (s *SuiteRemote) TestDisconnectedWhenNonConnected(c *C) {
fmt.Println("TestDisconnectedWhenNonConnected")
r := NewGitUploadPackService()
c.Assert(r.Disconnect(), Equals, ErrNotConnected)
}
func (s *SuiteRemote) TestAlreadyDisconnected(c *C) {
fmt.Println("TestAlreadyDisconnected")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
c.Assert(r.Disconnect(), IsNil)
c.Assert(r.Disconnect(), Equals, ErrNotConnected)
c.Assert(r.connected, Equals, false)
}
func (s *SuiteRemote) TestServeralConnections(c *C) {
fmt.Println("TestServeralConnections")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
c.Assert(r.Disconnect(), IsNil)
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
c.Assert(r.connected, Equals, true)
c.Assert(r.Disconnect(), IsNil)
c.Assert(r.connected, Equals, false)
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
c.Assert(r.connected, Equals, true)
c.Assert(r.Disconnect(), IsNil)
c.Assert(r.connected, Equals, false)
}
func (s *SuiteRemote) TestInfoNotConnected(c *C) {
fmt.Println("TestInfoNotConnected")
r := NewGitUploadPackService()
_, err := r.Info()
c.Assert(err, Equals, ErrNotConnected)
}
func (s *SuiteRemote) TestDefaultBranch(c *C) {
fmt.Println("TestDefaultBranch")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
defer func() { c.Assert(r.Disconnect(), IsNil) }()
info, err := r.Info()
c.Assert(err, IsNil)
c.Assert(info.Capabilities.SymbolicReference("HEAD"), Equals, "refs/heads/master")
}
func (s *SuiteRemote) TestCapabilities(c *C) {
fmt.Println("TestCapabilities")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
defer func() { c.Assert(r.Disconnect(), IsNil) }()
info, err := r.Info()
c.Assert(err, IsNil)
c.Assert(info.Capabilities.Get("agent").Values, HasLen, 1)
}
func (s *SuiteRemote) TestFetchNotConnected(c *C) {
fmt.Println("TestFetchNotConnected")
r := NewGitUploadPackService()
pr := &common.GitUploadPackRequest{}
pr.Want(core.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
_, err := r.Fetch(pr)
c.Assert(err, Equals, ErrNotConnected)
}
func (s *SuiteRemote) TestFetch(c *C) {
fmt.Println("TestFetch")
agent, err := newSSHAgentConn()
c.Assert(err, IsNil)
defer func() { c.Assert(agent.close(), IsNil) }()
r := NewGitUploadPackService()
c.Assert(r.ConnectWithAuth(fixRepo, agent.auth), IsNil)
defer func() { c.Assert(r.Disconnect(), IsNil) }()
pr := &common.GitUploadPackRequest{}
pr.Want(core.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.Fetch(pr)
c.Assert(err, IsNil)
b, err := ioutil.ReadAll(reader)
c.Assert(err, IsNil)
c.Assert(b, HasLen, 85374)
}
