| package git |
| |
| import ( |
| "gopkg.in/src-d/go-git.v4/config" |
| "gopkg.in/src-d/go-git.v4/core" |
| "gopkg.in/src-d/go-git.v4/storage/memory" |
| |
| . "gopkg.in/check.v1" |
| ) |
| |
| type RepositorySuite struct { |
| BaseSuite |
| } |
| |
| var _ = Suite(&RepositorySuite{}) |
| |
| func (s *RepositorySuite) TestNewRepository(c *C) { |
| r := NewMemoryRepository() |
| c.Assert(r, NotNil) |
| } |
| |
| func (s *RepositorySuite) TestCreateRemoteAndRemote(c *C) { |
| r := NewMemoryRepository() |
| remote, err := r.CreateRemote(&config.RemoteConfig{ |
| Name: "foo", |
| URL: "http://foo/foo.git", |
| }) |
| |
| c.Assert(err, IsNil) |
| c.Assert(remote.Config().Name, Equals, "foo") |
| |
| alt, err := r.Remote("foo") |
| c.Assert(err, IsNil) |
| c.Assert(alt, Not(Equals), remote) |
| c.Assert(alt.Config().Name, Equals, "foo") |
| } |
| |
| func (s *RepositorySuite) TestCreateRemoteInvalid(c *C) { |
| r := NewMemoryRepository() |
| remote, err := r.CreateRemote(&config.RemoteConfig{}) |
| |
| c.Assert(err, Equals, config.ErrRemoteConfigEmptyName) |
| c.Assert(remote, IsNil) |
| } |
| |
| func (s *RepositorySuite) TestDeleteRemote(c *C) { |
| r := NewMemoryRepository() |
| _, err := r.CreateRemote(&config.RemoteConfig{ |
| Name: "foo", |
| URL: "http://foo/foo.git", |
| }) |
| |
| c.Assert(err, IsNil) |
| |
| err = r.DeleteRemote("foo") |
| c.Assert(err, IsNil) |
| |
| alt, err := r.Remote("foo") |
| c.Assert(err, Equals, config.ErrRemoteConfigNotFound) |
| c.Assert(alt, IsNil) |
| } |
| |
| func (s *RepositorySuite) TestClone(c *C) { |
| r := NewMemoryRepository() |
| |
| head, err := r.Head() |
| c.Assert(err, Equals, core.ErrReferenceNotFound) |
| c.Assert(head, IsNil) |
| |
| err = r.Clone(&CloneOptions{ |
| URL: RepositoryFixture, |
| }) |
| |
| c.Assert(err, IsNil) |
| |
| remotes, err := r.Remotes() |
| c.Assert(err, IsNil) |
| c.Assert(remotes, HasLen, 1) |
| |
| head, err = r.Ref(core.HEAD, false) |
| c.Assert(err, IsNil) |
| c.Assert(head, NotNil) |
| c.Assert(head.Type(), Equals, core.SymbolicReference) |
| c.Assert(head.Target().String(), Equals, "refs/heads/master") |
| |
| branch, err := r.Ref(head.Target(), false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") |
| |
| branch, err = r.Ref("refs/remotes/origin/master", false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Type(), Equals, core.HashReference) |
| c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") |
| |
| branch, err = r.Ref("refs/remotes/origin/branch", false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Type(), Equals, core.HashReference) |
| c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") |
| } |
| |
| func (s *RepositorySuite) TestCloneNonEmpty(c *C) { |
| r := NewMemoryRepository() |
| |
| head, err := r.Head() |
| c.Assert(err, Equals, core.ErrReferenceNotFound) |
| c.Assert(head, IsNil) |
| |
| o := &CloneOptions{URL: RepositoryFixture} |
| err = r.Clone(o) |
| c.Assert(err, IsNil) |
| |
| err = r.Clone(o) |
| c.Assert(err, Equals, ErrRepositoryNonEmpty) |
| } |
| |
| func (s *RepositorySuite) TestCloneSingleBranchAndNonHEAD(c *C) { |
| r := NewMemoryRepository() |
| |
| head, err := r.Head() |
| c.Assert(err, Equals, core.ErrReferenceNotFound) |
| c.Assert(head, IsNil) |
| |
| err = r.Clone(&CloneOptions{ |
| URL: RepositoryFixture, |
| ReferenceName: core.ReferenceName("refs/heads/branch"), |
| SingleBranch: true, |
| }) |
| |
| c.Assert(err, IsNil) |
| |
| remotes, err := r.Remotes() |
| c.Assert(err, IsNil) |
| c.Assert(remotes, HasLen, 1) |
| |
| head, err = r.Ref(core.HEAD, false) |
| c.Assert(err, IsNil) |
| c.Assert(head, NotNil) |
| c.Assert(head.Type(), Equals, core.SymbolicReference) |
| c.Assert(head.Target().String(), Equals, "refs/heads/branch") |
| |
| branch, err := r.Ref(head.Target(), false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") |
| |
| branch, err = r.Ref("refs/remotes/origin/branch", false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Type(), Equals, core.HashReference) |
| c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") |
| } |
| |
| func (s *RepositorySuite) TestCloneSingleBranch(c *C) { |
| r := NewMemoryRepository() |
| |
| head, err := r.Head() |
| c.Assert(err, Equals, core.ErrReferenceNotFound) |
| c.Assert(head, IsNil) |
| |
| err = r.Clone(&CloneOptions{ |
| URL: RepositoryFixture, |
| SingleBranch: true, |
| }) |
| |
| c.Assert(err, IsNil) |
| |
| remotes, err := r.Remotes() |
| c.Assert(err, IsNil) |
| c.Assert(remotes, HasLen, 1) |
| |
| head, err = r.Ref(core.HEAD, false) |
| c.Assert(err, IsNil) |
| c.Assert(head, NotNil) |
| c.Assert(head.Type(), Equals, core.SymbolicReference) |
| c.Assert(head.Target().String(), Equals, "refs/heads/master") |
| |
| branch, err := r.Ref(head.Target(), false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") |
| |
| branch, err = r.Ref("refs/remotes/origin/master", false) |
| c.Assert(err, IsNil) |
| c.Assert(branch, NotNil) |
| c.Assert(branch.Type(), Equals, core.HashReference) |
| c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") |
| } |
| |
| func (s *RepositorySuite) TestCloneDetachedHEAD(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{ |
| URL: RepositoryFixture, |
| ReferenceName: core.ReferenceName("refs/tags/v1.0.0"), |
| }) |
| |
| head, err := r.Ref(core.HEAD, false) |
| c.Assert(err, IsNil) |
| c.Assert(head, NotNil) |
| c.Assert(head.Type(), Equals, core.HashReference) |
| c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") |
| } |
| |
| func (s *RepositorySuite) TestPull(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{ |
| URL: RepositoryFixture, |
| SingleBranch: true, |
| }) |
| |
| c.Assert(err, IsNil) |
| |
| err = r.Pull(&PullOptions{}) |
| c.Assert(err, Equals, NoErrAlreadyUpToDate) |
| |
| branch, err := r.Ref("refs/heads/master", false) |
| c.Assert(err, IsNil) |
| c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") |
| |
| storage := r.s.ObjectStorage().(*memory.ObjectStorage) |
| c.Assert(storage.Objects, HasLen, 31) |
| |
| r.CreateRemote(&config.RemoteConfig{ |
| Name: "foo", |
| URL: "https://github.com/git-fixtures/tags.git", |
| }) |
| |
| err = r.Pull(&PullOptions{RemoteName: "foo"}) |
| c.Assert(err, IsNil) |
| c.Assert(storage.Objects, HasLen, 38) |
| |
| branch, err = r.Ref("refs/heads/master", false) |
| c.Assert(err, IsNil) |
| c.Assert(branch.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") |
| } |
| |
| func (s *RepositorySuite) TestIsEmpty(c *C) { |
| r := NewMemoryRepository() |
| |
| empty, err := r.IsEmpty() |
| c.Assert(err, IsNil) |
| c.Assert(empty, Equals, true) |
| |
| err = r.Clone(&CloneOptions{URL: RepositoryFixture}) |
| c.Assert(err, IsNil) |
| |
| empty, err = r.IsEmpty() |
| c.Assert(err, IsNil) |
| c.Assert(empty, Equals, false) |
| } |
| |
| func (s *RepositorySuite) TestCommit(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{ |
| URL: RepositoryFixture, |
| }) |
| |
| c.Assert(err, IsNil) |
| |
| hash := core.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47") |
| commit, err := r.Commit(hash) |
| c.Assert(err, IsNil) |
| |
| c.Assert(commit.Hash.IsZero(), Equals, false) |
| c.Assert(commit.Hash, Equals, commit.ID()) |
| c.Assert(commit.Hash, Equals, hash) |
| c.Assert(commit.Type(), Equals, core.CommitObject) |
| |
| tree, err := commit.Tree() |
| c.Assert(err, IsNil) |
| c.Assert(tree.Hash.IsZero(), Equals, false) |
| |
| c.Assert(commit.Author.Email, Equals, "daniel@lordran.local") |
| } |
| |
| func (s *RepositorySuite) TestCommits(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: RepositoryFixture}) |
| c.Assert(err, IsNil) |
| |
| count := 0 |
| commits, err := r.Commits() |
| c.Assert(err, IsNil) |
| for { |
| commit, err := commits.Next() |
| if err != nil { |
| break |
| } |
| |
| count++ |
| c.Assert(commit.Hash.IsZero(), Equals, false) |
| c.Assert(commit.Hash, Equals, commit.ID()) |
| c.Assert(commit.Type(), Equals, core.CommitObject) |
| } |
| |
| c.Assert(count, Equals, 9) |
| } |
| |
| func (s *RepositorySuite) TestTag(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: "https://github.com/spinnaker/spinnaker.git"}) |
| c.Assert(err, IsNil) |
| |
| hash := core.NewHash("0a3fb06ff80156fb153bcdcc58b5e16c2d27625c") |
| tag, err := r.Tag(hash) |
| c.Assert(err, IsNil) |
| |
| c.Assert(tag.Hash.IsZero(), Equals, false) |
| c.Assert(tag.Hash, Equals, hash) |
| c.Assert(tag.Type(), Equals, core.TagObject) |
| } |
| |
| func (s *RepositorySuite) TestTags(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: "https://github.com/git-fixtures/tags.git"}) |
| c.Assert(err, IsNil) |
| |
| count := 0 |
| tags, err := r.Tags() |
| c.Assert(err, IsNil) |
| |
| tags.ForEach(func(tag *Tag) error { |
| count++ |
| c.Assert(tag.Hash.IsZero(), Equals, false) |
| c.Assert(tag.Type(), Equals, core.TagObject) |
| |
| return nil |
| }) |
| |
| refs, _ := r.Refs() |
| refs.ForEach(func(ref *core.Reference) error { |
| return nil |
| }) |
| |
| c.Assert(count, Equals, 4) |
| } |
| |
| func (s *RepositorySuite) TestCommitIterClosePanic(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: RepositoryFixture}) |
| c.Assert(err, IsNil) |
| |
| commits, err := r.Commits() |
| c.Assert(err, IsNil) |
| commits.Close() |
| } |
| |
| func (s *RepositorySuite) TestRef(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: RepositoryFixture}) |
| c.Assert(err, IsNil) |
| |
| ref, err := r.Ref(core.HEAD, false) |
| c.Assert(err, IsNil) |
| c.Assert(ref.Name(), Equals, core.HEAD) |
| |
| ref, err = r.Ref(core.HEAD, true) |
| c.Assert(err, IsNil) |
| c.Assert(ref.Name(), Equals, core.ReferenceName("refs/heads/master")) |
| } |
| |
| func (s *RepositorySuite) TestRefs(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: RepositoryFixture}) |
| c.Assert(err, IsNil) |
| |
| c.Assert(err, IsNil) |
| |
| iter, err := r.Refs() |
| c.Assert(err, IsNil) |
| c.Assert(iter, NotNil) |
| } |
| |
| func (s *RepositorySuite) TestObject(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: "https://github.com/spinnaker/spinnaker.git"}) |
| c.Assert(err, IsNil) |
| |
| hash := core.NewHash("0a3fb06ff80156fb153bcdcc58b5e16c2d27625c") |
| tag, err := r.Tag(hash) |
| c.Assert(err, IsNil) |
| |
| c.Assert(tag.Hash.IsZero(), Equals, false) |
| c.Assert(tag.Hash, Equals, hash) |
| c.Assert(tag.Type(), Equals, core.TagObject) |
| } |
| |
| func (s *RepositorySuite) TestObjectNotFound(c *C) { |
| r := NewMemoryRepository() |
| err := r.Clone(&CloneOptions{URL: "https://github.com/git-fixtures/basic.git"}) |
| c.Assert(err, IsNil) |
| |
| hash := core.NewHash("0a3fb06ff80156fb153bcdcc58b5e16c2d27625c") |
| tag, err := r.Object(core.TagObject, hash) |
| c.Assert(err, DeepEquals, core.ErrObjectNotFound) |
| c.Assert(tag, IsNil) |
| } |