func (r *Repository) updateRemoteConfig(
remote *Remote, o *CloneOptions, c *config.RemoteConfig,
) error {
if !o.SingleBranch {
return nil
}
head, err := storer.ResolveReference(remote.Info().Refs, o.ReferenceName)
if err != nil {
return err
}
c.Fetch = []config.RefSpec{
config.RefSpec(fmt.Sprintf(refspecSingleBranch, head.Name().Short(), c.Name)),
}
cfg, err := r.s.Config()
if err != nil {
return err
}
cfg.Remotes[c.Name] = c
return r.s.SetConfig(cfg)
}
func (s *RemoteSuite) TestFetchWithPackfileWriter(c *C) {
dir, err := ioutil.TempDir("", "fetch")
c.Assert(err, IsNil)
defer os.RemoveAll(dir) // clean up
fss, err := filesystem.NewStorage(osfs.New(dir))
c.Assert(err, IsNil)
mock := &mockPackfileWriter{Storer: fss}
url := s.GetBasicLocalRepositoryURL()
r := newRemote(mock, nil, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err = r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
})
c.Assert(err, IsNil)
var count int
iter, err := mock.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
iter.ForEach(func(plumbing.EncodedObject) error {
count++
return nil
})
c.Assert(count, Equals, 31)
c.Assert(mock.PackfileWriterCalled, Equals, true)
}
func (s *RemoteSuite) TestFetchDepth(c *C) {
url := s.GetBasicLocalRepositoryURL()
sto := memory.NewStorage()
r := newRemote(sto, nil, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
Depth: 1,
})
c.Assert(err, IsNil)
c.Assert(sto.Objects, HasLen, 18)
expectedRefs := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
}
for _, exp := range expectedRefs {
r, _ := sto.Reference(exp.Name())
c.Assert(exp.String(), Equals, r.String())
}
h, err := sto.Shallow()
c.Assert(err, IsNil)
c.Assert(h, HasLen, 2)
c.Assert(h, DeepEquals, []plumbing.Hash{
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
}
func (s *RemoteSuite) TestPushInvalidRefSpec(c *C) {
r := newRemote(nil, nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URL: "file:///some-url",
})
rs := config.RefSpec("^*$**")
err := r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, ErrorMatches, ".*invalid.*")
}
func (c *ConfigStorage) unmarshalRemote(s *gitconfig.Subsection) *config.RemoteConfig {
fetch := []config.RefSpec{}
for _, f := range s.Options.GetAll(fetchKey) {
rs := config.RefSpec(f)
if rs.IsValid() {
fetch = append(fetch, rs)
}
}
return &config.RemoteConfig{
Name: s.Name,
URL: s.Option(urlKey),
Fetch: fetch,
}
}
func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDate(c *C) {
url := s.GetBasicLocalRepositoryURL()
sto := memory.NewStorage()
r := newRemote(sto, nil, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
o := &FetchOptions{
RefSpecs: []config.RefSpec{refspec},
}
err := r.Fetch(o)
c.Assert(err, IsNil)
err = r.Fetch(o)
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *RemoteSuite) TestPushNoErrAlreadyUpToDate(c *C) {
f := fixtures.Basic().One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
url := fmt.Sprintf("file://%s", f.DotGit().Base())
r := newRemote(sto, nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URL: url,
})
rs := config.RefSpec("refs/heads/*:refs/heads/*")
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *RemoteSuite) TestFetchWithProgress(c *C) {
url := s.GetBasicLocalRepositoryURL()
sto := memory.NewStorage()
buf := bytes.NewBuffer(nil)
r := newRemote(sto, buf, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
})
c.Assert(err, IsNil)
c.Assert(sto.Objects, HasLen, 31)
c.Assert(buf.Len(), Not(Equals), 0)
}
// Validate validate the fields and set the default values
func (o *PushOptions) Validate() error {
if o.RemoteName == "" {
o.RemoteName = DefaultRemoteName
}
if len(o.RefSpecs) == 0 {
o.RefSpecs = []config.RefSpec{
config.RefSpec(config.DefaultPushRefSpec),
}
}
for _, r := range o.RefSpecs {
if !r.IsValid() {
return ErrInvalidRefSpec
}
}
return nil
}
func (s *RemoteSuite) TestPushToEmptyRepository(c *C) {
srcFs := fixtures.Basic().One().DotGit()
sto, err := filesystem.NewStorage(srcFs)
c.Assert(err, IsNil)
dstFs := fixtures.ByTag("empty").One().DotGit()
url := fmt.Sprintf("file://%s", dstFs.Base())
r := newRemote(sto, nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URL: url,
})
rs := config.RefSpec("refs/heads/*:refs/heads/*")
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, IsNil)
dstSto, err := filesystem.NewStorage(dstFs)
c.Assert(err, IsNil)
dstRepo, err := NewRepository(dstSto)
c.Assert(err, IsNil)
iter, err := sto.IterReferences()
c.Assert(err, IsNil)
err = iter.ForEach(func(ref *plumbing.Reference) error {
if !ref.IsBranch() {
return nil
}
dstRef, err := dstRepo.Reference(ref.Name(), true)
c.Assert(err, IsNil, Commentf("ref: %s", ref.String()))
c.Assert(dstRef, DeepEquals, ref)
return nil
})
c.Assert(err, IsNil)
}
"os"
"time"
"gopkg.in/src-d/go-git.v4/config"
"gopkg.in/src-d/go-git.v4/plumbing"
"gopkg.in/src-d/go-git.v4/plumbing/client"
githttp "gopkg.in/src-d/go-git.v4/plumbing/client/http"
"gopkg.in/src-d/go-git.v4/plumbing/storer"
"gopkg.in/src-d/go-git.v4/storage/filesystem"
"gopkg.in/src-d/go-git.v4/storage/memory"
osfs "gopkg.in/src-d/go-git.v4/utils/fs/os"
. "gopkg.in/check.v1"
)
const FixRefSpec = config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
type RemoteSuite struct {
BaseSuite
}
var _ = Suite(&RemoteSuite{})
func (s *RemoteSuite) TestConnect(c *C) {
r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: RepositoryFixture})
err := r.Connect()
c.Assert(err, IsNil)
}
func (s *RemoteSuite) TestnewRemoteInvalidEndpoint(c *C) {
func (s *RemoteSuite) TestFetchInvalidFetchOptions(c *C) {
r := newRemote(nil, nil, &config.RemoteConfig{Name: "foo", URL: "qux://foo"})
invalid := config.RefSpec("^*$ñ")
err := r.Fetch(&FetchOptions{RefSpecs: []config.RefSpec{invalid}})
c.Assert(err, Equals, ErrInvalidRefSpec)
}