Change git compare from using browser to using "git log"

Also,

* add unit test for gitCompareVersion
* use defined variable for standard output and error so we can use it on
  testing

6 files changed, 190 insertions, 26 deletions

diff --git a/beku.go b/beku.go
index 7af3e93..af80fad 100644
--- a/beku.go
+++ b/beku.go
@@ -2,6 +2,7 @@ package beku
 
 import (
 	"errors"
+	"os"
 )
 
 const (
@@ -24,7 +25,7 @@ const (
 	envDEBUG = "BEKU_DEBUG"
 
 	msgUpdateProceed = "Proceed with update?"
-	msgUpdateView    = "Compare changes on browser?"
+	msgUpdateView    = "View commit logs?"
 
 	prefixTag = 'v'
 
@@ -59,6 +60,9 @@ var (
 )
 
 var (
+	defStdout = os.Stdout
+	defStderr = os.Stderr
+
 	sectionPackage = "package"
 
 	keyDeps        = "deps"
diff --git a/env.go b/env.go
index 59cc821..0a78951 100644
--- a/env.go
+++ b/env.go
@@ -390,7 +390,7 @@ func (env *Env) update(curPkg, newPkg *Package) (ok bool, err error) {
 
 	ok = confirm(os.Stdin, msgUpdateView, false)
 	if ok {
-		err = curPkg.BrowseCompare(newPkg)
+		err = curPkg.CompareVersion(newPkg)
 		if err != nil {
 			return
 		}
diff --git a/package.go b/package.go
index 632b078..f3d42c3 100644
--- a/package.go
+++ b/package.go
@@ -57,13 +57,12 @@ func NewPackage(pkgName, importPath string, vcsMode VCSMode) (
 }
 
 //
-// BrowseCompare will open a browser, using xdg-open, to compare package
-// version using current package as base.
+// CompareVersion will compare package version using current package as base.
 //
-func (pkg *Package) BrowseCompare(fork *Package) (err error) {
+func (pkg *Package) CompareVersion(newPkg *Package) (err error) {
 	switch pkg.vcs {
 	case VCSModeGit:
-		err = pkg.gitBrowseCompare(fork)
+		err = pkg.gitCompareVersion(newPkg)
 	}
 
 	return
diff --git a/package_git.go b/package_git.go
index 29710bb..46e006d 100644
--- a/package_git.go
+++ b/package_git.go
@@ -6,33 +6,22 @@ import (
 	"log"
 	"os"
 	"os/exec"
-	"strings"
 
 	"github.com/shuLhan/share/lib/ini"
 )
 
-func (pkg *Package) gitBrowseCompare(fork *Package) (err error) {
-	forkRemoteURL := strings.Split(fork.RemoteURL, "/")
-	if len(forkRemoteURL) < 4 {
-		err = fmt.Errorf("gitBrowseCompare: %s", ErrRemote)
-		return
-	}
-
-	cmpURL := pkg.RemoteURL + "/compare/" + pkg.Version + "..."
-
-	if pkg.RemoteURL != fork.RemoteURL {
-		cmpURL += forkRemoteURL[3] + ":" + fork.Version
-	} else {
-		cmpURL += fork.Version
-	}
-
-	cmd := exec.Command("xdg-open", cmpURL)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+//
+// gitCompareVersion compare the version of current package with new package.
+//
+func (pkg *Package) gitCompareVersion(newPkg *Package) (err error) {
+	cmd := exec.Command("git", "log", "--oneline", pkg.Version+"..."+newPkg.Version)
+	cmd.Dir = pkg.FullPath
+	cmd.Stdout = defStdout
+	cmd.Stderr = defStderr
 
 	err = cmd.Run()
 	if err != nil {
-		err = fmt.Errorf("gitBrowseCompare: %s", err)
+		err = fmt.Errorf("gitCompareVersion: %s", err)
 		return
 	}
 
diff --git a/package_git_test.go b/package_git_test.go
new file mode 100644
index 0000000..7ae7af5
--- /dev/null
+++ b/package_git_test.go
@@ -0,0 +1,172 @@
+package beku
+
+import (
+	"go/build"
+	"io"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/shuLhan/share/lib/test"
+)
+
+var (
+	gitCurPkg  *Package
+	gitNewPkg  *Package
+	testStdout *os.File
+	testStderr *os.File
+)
+
+func testInitOutput() (err error) {
+	testStdout, err = ioutil.TempFile("", "")
+	if err != nil {
+		return
+	}
+
+	testStderr, err = ioutil.TempFile("", "")
+	if err != nil {
+		return
+	}
+
+	defStdout = testStdout
+	defStderr = testStderr
+
+	return
+}
+
+func testResetOutput(t *testing.T, truncate bool) {
+	_, err := testStdout.Seek(0, io.SeekStart)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = testStderr.Seek(0, io.SeekStart)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if truncate {
+		testStdout.Truncate(0)
+		testStderr.Truncate(0)
+	}
+}
+
+func testGitCompareVersion(t *testing.T) {
+	cases := []struct {
+		desc       string
+		curVersion string
+		newVersion string
+		expErr     string
+		expStdout  string
+		expStderr  string
+	}{{
+		desc: "With empty versions",
+	}, {
+		desc:       "With invalid new version",
+		curVersion: "v0.1.0",
+		newVersion: "abcdef01",
+		expErr:     "gitCompareVersion: exit status 128",
+		expStderr: `fatal: ambiguous argument 'v0.1.0...abcdef01': unknown revision or path not in the working tree.
+Use '--' to separate paths from revisions, like this:
+'git <command> [<revision>...] -- [<file>...]'
+`,
+	}, {
+		desc:       "With empty on new version",
+		curVersion: "v0.1.0",
+		expStdout: `582b912 Add feature B.
+ec65455 Add feature A.
+`,
+	}, {
+		desc:       "With empty on current version #1",
+		newVersion: "v0.1.0",
+		expStdout: `582b912 Add feature B.
+ec65455 Add feature A.
+`,
+	}, {
+		desc:       "With empty on current version #2",
+		newVersion: "v0.2.0",
+	}, {
+		desc:       "With empty on new version (latest tag)",
+		curVersion: "v0.2.0",
+	}, {
+		desc:       "With valid versions",
+		curVersion: "v0.1.0",
+		newVersion: "v0.2.0",
+		expStdout: `582b912 Add feature B.
+ec65455 Add feature A.
+`,
+	}, {
+		desc:       "With valid versions, but reversed",
+		curVersion: "v0.2.0",
+		newVersion: "v0.1.0",
+		expStdout: `582b912 Add feature B.
+ec65455 Add feature A.
+`,
+	}}
+
+	var (
+		err            error
+		bout, berr     []byte
+		stdout, stderr string
+	)
+
+	for _, c := range cases {
+		t.Log(c.desc)
+
+		gitCurPkg.Version = c.curVersion
+		gitNewPkg.Version = c.newVersion
+
+		err = gitCurPkg.CompareVersion(gitNewPkg)
+		if err != nil {
+			test.Assert(t, "err", c.expErr, err.Error(), true)
+		}
+
+		testResetOutput(t, false)
+
+		bout, err = ioutil.ReadAll(defStdout)
+		if err != nil {
+			t.Fatal(err)
+		}
+		berr, err = ioutil.ReadAll(testStderr)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		stdout = string(bout)
+		stderr = string(berr)
+
+		test.Assert(t, "stdout", c.expStdout, stdout, true)
+		test.Assert(t, "stderr", c.expStderr, stderr, true)
+
+		testResetOutput(t, true)
+	}
+}
+
+func TestGit(t *testing.T) {
+	orgGOPATH := build.Default.GOPATH
+
+	testGOPATH, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	testGOPATH += "/testdata"
+	build.Default.GOPATH = testGOPATH
+
+	defer func() {
+		build.Default.GOPATH = orgGOPATH
+	}()
+
+	err = testInitOutput()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gitCurPkg = NewPackage("git", "git", VCSModeGit)
+	gitNewPkg = NewPackage("git", "git", VCSModeGit)
+
+	t.Logf("gitCurPkg: %+v\n", *gitCurPkg)
+	t.Logf("gitNewPkg: %+v\n", *gitNewPkg)
+
+	t.Run("CompareVersion", testGitCompareVersion)
+}
diff --git a/testdata/src/git b/testdata/src/git
new file mode 160000
+Subproject 582b912d9958422308dd6aaca85bc15a0463086