repo_remote: add unit tests

Author: unknwon

error.go

@@ -12,6 +12,7 @@ var (
 	ErrParentNotExist    = errors.New("parent does not exist")
 	ErrSubmoduleNotExist = errors.New("submodule does not exist")
 	ErrRevisionNotExist  = errors.New("revision does not exist")
+	ErrRemoteNotExist    = errors.New("remote does not exist")
 	ErrExecTimeout       = errors.New("execution was timed out")
 	ErrNoMergeBase       = errors.New("no merge based was found")
 )

repo_reference.go

@@ -58,7 +58,8 @@ func (r *Repository) ShowRefVerify(ref string, opts ...ShowRefVerifyOptions) (st
 	return strings.Split(string(stdout), " ")[0], nil
 }
 
-// HasReference returns true if given reference exists in the repository.
+// HasReference returns true if given reference exists in the repository. The reference must be
+// given in full path, e.g. refs/heads/master
 func (r *Repository) HasReference(ref string, opts ...ShowRefVerifyOptions) bool {
 	_, err := r.ShowRefVerify(ref, opts...)
 	return err == nil

repo_reference_test.go

@@ -104,8 +104,7 @@ func TestRepository_ShowRef(t *testing.T) {
 					Refspec: "refs/heads/release-1.0",
 				},
 			},
-		},
-		{
+		}, {
 			opt: ShowRefOptions{
 				Tags:     true,
 				Patterns: []string{"v1.0.0"},

repo_remote.go

@@ -19,16 +19,16 @@ type LsRemoteOptions struct {
 	Tags bool
 	// Indicates whether to not show peeled tags or pseudorefs.
 	Refs bool
-	// The URL of the remote repository.
-	URL string
+	// The list of patterns to filter results.
+	Patterns []string
 	// The timeout duration before giving up. The default timeout duration will be used when not supplied.
 	Timeout time.Duration
 }
 
 // LsRemote returns a list references in the remote repository.
-func LsRemote(opts ...LsRemoteOptions) ([]*Reference, error) {
+func LsRemote(url string, opts ...LsRemoteOptions) ([]*Reference, error) {
 	var opt LsRemoteOptions
-	if len(opts) > 1 {
+	if len(opts) > 0 {
 		opt = opts[0]
 	}
 
@@ -42,8 +42,9 @@ func LsRemote(opts ...LsRemoteOptions) ([]*Reference, error) {
 	if opt.Refs {
 		cmd.AddArgs("--refs")
 	}
-	if opt.URL != "" {
-		cmd.AddArgs(opt.URL)
+	cmd.AddArgs(url)
+	if len(opt.Patterns) > 0 {
+		cmd.AddArgs(opt.Patterns...)
 	}
 
 	stdout, err := cmd.RunWithTimeout(opt.Timeout)
@@ -69,14 +70,15 @@ func LsRemote(opts ...LsRemoteOptions) ([]*Reference, error) {
 
 // IsURLAccessible returns true if given remote URL is accessible via Git.
 func IsURLAccessible(timeout time.Duration, url string) bool {
-	_, err := LsRemote(LsRemoteOptions{
-		URL:     url,
-		Timeout: timeout,
+	_, err := LsRemote(url, LsRemoteOptions{
+		Patterns: []string{"HEAD"},
+		Timeout:  timeout,
 	})
 	return err == nil
 }
 
 // AddRemoteOptions contains options to add a remote address.
+// Docs: https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emaddem
 type AddRemoteOptions struct {
 	// Indicates whether to execute git fetch after the remote information is set up.
 	Fetch bool
@@ -89,7 +91,7 @@ type AddRemoteOptions struct {
 // AddRemote adds a new remote to the repository.
 func (r *Repository) AddRemote(name, url string, opts ...AddRemoteOptions) error {
 	var opt AddRemoteOptions
-	if len(opts) > 1 {
+	if len(opts) > 0 {
 		opt = opts[0]
 	}
 
@@ -115,12 +117,15 @@ type RemoveRemoteOptions struct {
 // RemoveRemote removes a remote from the repository.
 func (r *Repository) RemoveRemote(name string, opts ...RemoveRemoteOptions) error {
 	var opt RemoveRemoteOptions
-	if len(opts) > 1 {
+	if len(opts) > 0 {
 		opt = opts[0]
 	}
 
 	_, err := NewCommand("remote", "remove", name).RunInDirWithTimeout(opt.Timeout, r.path)
-	if err != nil && !strings.Contains(err.Error(), "fatal: No such remote") {
+	if err != nil {
+		if strings.Contains(err.Error(), "fatal: No such remote") {
+			return ErrRemoteNotExist
+		}
 		return err
 	}
 	return nil

repo_remote_test.go

@@ -0,0 +1,129 @@
+package git
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLsRemote(t *testing.T) {
+	tests := []struct {
+		url     string
+		opt     LsRemoteOptions
+		expRefs []*Reference
+	}{
+		{
+			url: testrepo.Path(),
+			opt: LsRemoteOptions{
+				Heads:    true,
+				Patterns: []string{"release-1.0"},
+			},
+			expRefs: []*Reference{
+				{
+					ID:      "0eedd79eba4394bbef888c804e899731644367fe",
+					Refspec: "refs/heads/release-1.0",
+				},
+			},
+		}, {
+			url: testrepo.Path(),
+			opt: LsRemoteOptions{
+				Tags:     true,
+				Patterns: []string{"v1.0.0"},
+			},
+			expRefs: []*Reference{
+				{
+					ID:      "0eedd79eba4394bbef888c804e899731644367fe",
+					Refspec: "refs/tags/v1.0.0",
+				},
+			},
+		}, {
+			url: testrepo.Path(),
+			opt: LsRemoteOptions{
+				Refs:     true,
+				Patterns: []string{"v1.0.0"},
+			},
+			expRefs: []*Reference{
+				{
+					ID:      "0eedd79eba4394bbef888c804e899731644367fe",
+					Refspec: "refs/tags/v1.0.0",
+				},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run("", func(t *testing.T) {
+			refs, err := LsRemote(test.url, test.opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			assert.Equal(t, test.expRefs, refs)
+		})
+	}
+}
+
+func TestIsURLAccessible(t *testing.T) {
+	tests := []struct {
+		url    string
+		expVal bool
+	}{
+		{
+			url:    testrepo.Path(),
+			expVal: true,
+		}, {
+			url:    os.TempDir(),
+			expVal: false,
+		},
+	}
+	for _, test := range tests {
+		t.Run("", func(t *testing.T) {
+			assert.Equal(t, test.expVal, IsURLAccessible(DefaultTimeout, test.url))
+		})
+	}
+}
+
+func TestRepository_AddRemote(t *testing.T) {
+	path := tempPath()
+	defer func() {
+		_ = os.RemoveAll(path)
+	}()
+
+	err := Init(path, InitOptions{
+		Bare: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	r, err := Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Add testrepo as the mirror remote and fetch right away
+	err = r.AddRemote("origin", testrepo.Path(), AddRemoteOptions{
+		Fetch:       true,
+		MirrorFetch: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check a non-default branch: release-1.0
+	assert.True(t, r.HasReference(RefsHeads+"release-1.0"))
+}
+
+func TestRepository_RemoveRemote(t *testing.T) {
+	r, cleanup, err := setupTempRepo()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer cleanup()
+
+	err = r.RemoveRemote("origin", RemoveRemoteOptions{})
+	assert.Nil(t, err)
+
+	err = r.RemoveRemote("origin", RemoveRemoteOptions{})
+	assert.Equal(t, ErrRemoteNotExist, err)
+}

repo_tag.go

@@ -6,6 +6,7 @@ package git
 
 import (
 	"bytes"
+	"fmt"
 	"strings"
 	"time"
 
@@ -92,6 +93,8 @@ func (r *Repository) getTag(timeout time.Duration, id *SHA1) (*Tag, error) {
 
 		tag.id = id
 		tag.repo = r
+	default:
+		return nil, fmt.Errorf("unsupported tag type: %s", ObjectType(typ))
 	}
 
 	r.cachedTags.Set(id.String(), tag)