Set up test repository (#44)

* test: set up testrepo

* test: print log to os.Stdout

* test: fix lint

* command: implement dual writer

* commit: add some unit tests

* command: print command together with the stdout

Author: unknwon

.gitignore

@@ -1,3 +1,4 @@
 .idea
 *.sublime-project
 *.sublime-workspace
+/testdata

.travis.yml

@@ -9,4 +9,4 @@ go:
 
 install: go get -v -t ./...
 script:
-  - go test -v -cover -race
+  - go test -v -cover -race -verbose

appveyor.yml

@@ -13,4 +13,4 @@ deploy: false
 install:
   - go version
   - go env
-  - go test -v -cover -race
+  - go test -v -cover -race -verbose

blob.go

@@ -11,7 +11,6 @@ import (
 
 // Blob is a blob object.
 type Blob struct {
-	repo *Repository
 	*TreeEntry
 }
 
@@ -22,7 +21,7 @@ func (b *Blob) Bytes() ([]byte, error) {
 	stderr := new(bytes.Buffer)
 
 	// Preallocate memory to save ~50% memory usage on big files.
-	stdout.Grow(int(b.Size() + 2048))
+	stdout.Grow(int(b.Size()))
 
 	if err := b.Pipeline(stdout, stderr); err != nil {
 		return nil, concatenateError(err, stderr.String())
@@ -32,5 +31,5 @@ func (b *Blob) Bytes() ([]byte, error) {
 
 // Pipeline reads the content of the blob and pipes stdout and stderr to supplied io.Writer.
 func (b *Blob) Pipeline(stdout, stderr io.Writer) error {
-	return NewCommand("show", b.id.String()).RunInDirPipeline(stdout, stderr, b.repo.path)
+	return NewCommand("show", b.id.String()).RunInDirPipeline(stdout, stderr, b.parent.repo.path)
 }

blob_test.go

@@ -12,32 +12,30 @@ import (
 )
 
 func TestBlob(t *testing.T) {
-	expOutput := `Copyright (c) 2015 All Gogs Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.`
+	expOutput := `This is a sample project students can use during Matthew's Git class.
+
+Here is an addition by me
+
+We can have a bit of fun with this repo, knowing that we can always reset it to a known good state.  We can apply labels, and branch, then add new code and merge it in to the master branch.
+
+As a quick reminder, this came from one of three locations in either SSH, Git, or HTTPS format:
+
+* git@github.com:matthewmccullough/hellogitworld.git
+* git://github.com/matthewmccullough/hellogitworld.git
+* https://matthewmccullough@github.com/matthewmccullough/hellogitworld.git
+
+We can, as an example effort, even modify this README and change it as if it were source code for the purposes of the class.
+
+This demo also includes an image with changes on a branch for examination of image diff on GitHub.
+`
 
 	blob := &Blob{
-		repo: &Repository{},
 		TreeEntry: &TreeEntry{
-			id: MustIDFromString("176d8dfe018c850d01851b05fb8a430096247353"), // Blob ID of "LICENSE" file
+			mode: EntryBlob,
+			typ:  ObjectBlob,
+			id:   MustIDFromString("adfd6da3c0a3fb038393144becbf37f14f780087"), // Blob ID of "README.txt" file
 			parent: &Tree{
-				repo: &Repository{},
+				repo: testrepo,
 			},
 		},
 	}

command.go

@@ -53,6 +53,34 @@ func (c *Command) AddEnvs(envs ...string) *Command {
 // DefaultTimeout is the default timeout duration for all commands.
 const DefaultTimeout = time.Minute
 
+// A limitDualWriter writes to W but limits the amount of data written to just N bytes.
+// On the other hand, it passes everything to w.
+type limitDualWriter struct {
+	W        io.Writer // underlying writer
+	N        int64     // max bytes remaining
+	prompted bool
+
+	w io.Writer
+}
+
+func (w *limitDualWriter) Write(p []byte) (int, error) {
+	if w.N > 0 {
+		limit := int64(len(p))
+		if limit > w.N {
+			limit = w.N
+		}
+		n, _ := w.W.Write(p[:limit])
+		w.N -= int64(n)
+	}
+
+	if !w.prompted && w.N <= 0 {
+		w.prompted = true
+		_, _ = w.W.Write([]byte("... (more omitted)"))
+	}
+
+	return w.w.Write(p)
+}
+
 // RunInDirPipelineWithTimeout executes the command in given directory and timeout duration.
 // It pipes stdout and stderr to supplied io.Writer. DefaultTimeout will be used if the timeout
 // duration is less than time.Nanosecond (i.e. less than or equal to 0).
@@ -61,12 +89,25 @@ func (c *Command) RunInDirPipelineWithTimeout(timeout time.Duration, stdout, std
 		timeout = DefaultTimeout
 	}
 
-	if len(dir) == 0 {
-		log("[timeout: %v] %s", timeout, c)
-	} else {
-		log("[timeout: %v] %s: %s", timeout, dir, c)
+	buf := new(bytes.Buffer)
+	w := stdout
+	if logOutput != nil {
+		buf.Grow(512)
+		w = &limitDualWriter{
+			W: buf,
+			N: int64(buf.Cap()),
+			w: stdout,
+		}
 	}
 
+	defer func() {
+		if len(dir) == 0 {
+			log("[timeout: %v] %s\n%s", timeout, c, buf.Bytes())
+		} else {
+			log("[timeout: %v] %s: %s\n%s", timeout, dir, c, buf.Bytes())
+		}
+	}()
+
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
@@ -75,7 +116,7 @@ func (c *Command) RunInDirPipelineWithTimeout(timeout time.Duration, stdout, std
 		cmd.Env = append(os.Environ(), c.envs...)
 	}
 	cmd.Dir = dir
-	cmd.Stdout = stdout
+	cmd.Stdout = w
 	cmd.Stderr = stderr
 	if err := cmd.Start(); err != nil {
 		return err
@@ -115,10 +156,6 @@ func (c *Command) RunInDirWithTimeout(timeout time.Duration, dir string) ([]byte
 	if err := c.RunInDirPipelineWithTimeout(timeout, stdout, stderr, dir); err != nil {
 		return nil, concatenateError(err, stderr.String())
 	}
-
-	if stdout.Len() > 0 {
-		log("stdout:\n%s", stdout.Bytes()[:1024])
-	}
 	return stdout.Bytes(), nil
 }
 

commit.go

@@ -50,6 +50,12 @@ func (c *Commit) Summary() string {
 	return strings.Split(c.message, "\n")[0]
 }
 
+// ParentsCount returns number of parents of the commit.
+// It returns 0 if this is the root commit, otherwise returns 1, 2, etc.
+func (c *Commit) ParentsCount() int {
+	return len(c.parents)
+}
+
 // ParentID returns the SHA-1 hash of the n-th parent (0-based) of this commit.
 // It returns ErrRevisionNotExist if no such parent exists.
 func (c *Commit) ParentID(n int) (*SHA1, error) {
@@ -70,12 +76,6 @@ func (c *Commit) Parent(n int, opts ...CatFileCommitOptions) (*Commit, error) {
 	return c.repo.CatFileCommit(id.String(), opts...)
 }
 
-// ParentsCount returns number of parents of the commit.
-// It returns 0 if this is the root commit, otherwise returns 1, 2, etc.
-func (c *Commit) ParentsCount() int {
-	return len(c.parents)
-}
-
 // CommitByPath returns the commit of the path in the state of this commit.
 func (c *Commit) CommitByPath(opts ...CommitByRevisionOptions) (*Commit, error) {
 	return c.repo.CommitByRevision(c.id.String(), opts...)

commit_test.go

@@ -0,0 +1,88 @@
+package git
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCommit(t *testing.T) {
+	c, err := testrepo.CatFileCommit("435ffceb7ba576c937e922766e37d4f7abdcc122")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Run("ID", func(t *testing.T) {
+		assert.Equal(t, "435ffceb7ba576c937e922766e37d4f7abdcc122", c.ID().String())
+	})
+
+	author := &Signature{
+		Name:  "Jordan McCullough",
+		Email: "jordan@github.com",
+		When:  time.Unix(1415213395, 0),
+	}
+	t.Run("Author", func(t *testing.T) {
+		assert.Equal(t, author.Name, c.Author().Name)
+		assert.Equal(t, author.Email, c.Author().Email)
+		assert.Equal(t, author.When.Unix(), c.Author().When.Unix())
+	})
+
+	t.Run("Committer", func(t *testing.T) {
+		assert.Equal(t, author.Name, c.Committer().Name)
+		assert.Equal(t, author.Email, c.Committer().Email)
+		assert.Equal(t, author.When.Unix(), c.Committer().When.Unix())
+	})
+
+	t.Run("Message", func(t *testing.T) {
+		message := `Merge pull request #35 from githubtraining/travis-yml-docker
+
+Add special option flag for Travis Docker use case`
+		assert.Equal(t, message, c.Message())
+	})
+
+	t.Run("Summary", func(t *testing.T) {
+		assert.Equal(t, "Merge pull request #35 from githubtraining/travis-yml-docker", c.Summary())
+	})
+}
+
+func TestCommit_Parent(t *testing.T) {
+	c, err := testrepo.CatFileCommit("435ffceb7ba576c937e922766e37d4f7abdcc122")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Run("ParentsCount", func(t *testing.T) {
+		assert.Equal(t, 2, c.ParentsCount())
+	})
+
+	t.Run("Parent", func(t *testing.T) {
+		t.Run("no such parent", func(t *testing.T) {
+			_, err := c.Parent(c.ParentsCount() + 1)
+			assert.NotNil(t, err)
+			assert.Equal(t, `revision does not exist [rev: , path: ]`, err.Error())
+		})
+
+		tests := []struct {
+			n        int
+			parentID string
+		}{
+			{
+				n:        0,
+				parentID: "a13dba1e469944772490909daa58c53ac8fa4b0d",
+			},
+			{
+				n:        1,
+				parentID: "7c5ee6478d137417ae602140c615e33aed91887c",
+			},
+		}
+		for _, test := range tests {
+			t.Run("", func(t *testing.T) {
+				p, err := c.Parent(test.n)
+				if err != nil {
+					t.Fatal(err)
+				}
+				assert.Equal(t, test.parentID, p.ID().String())
+			})
+		}
+	})
+}

git_test.go

@@ -2,21 +2,45 @@ package git
 
 import (
 	"bytes"
+	"flag"
 	"fmt"
+	stdlog "log"
+	"os"
 	"testing"
 
 	goversion "github.com/mcuadros/go-version"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/sync/errgroup"
 )
 
-func TestSetOutput(t *testing.T) {
-	assert.Nil(t, logOutput)
+const repoPath = "testdata/testrepo.git"
 
-	var buf bytes.Buffer
-	SetOutput(&buf)
+var testrepo *Repository
 
-	assert.NotNil(t, logOutput)
+func TestMain(m *testing.M) {
+	verbose := flag.Bool("verbose", false, "")
+	flag.Parse()
+
+	if *verbose {
+		SetOutput(os.Stdout)
+	}
+
+	// Set up the test repository
+	if !isExist(repoPath) {
+		if err := Clone("https://github.com/gogs/git-module-testrepo.git", repoPath, CloneOptions{
+			Bare: true,
+		}); err != nil {
+			stdlog.Fatal(err)
+		}
+	}
+
+	var err error
+	testrepo, err = Open(repoPath)
+	if err != nil {
+		stdlog.Fatal(err)
+	}
+
+	os.Exit(m.Run())
 }
 
 func TestSetPrefix(t *testing.T) {

repo.go

@@ -79,16 +79,16 @@ func Init(path string, opts ...InitOptions) error {
 
 // Open opens the repository at the given path. It returns an os.ErrNotExist
 // if the path does not exist.
-func Open(path string) (*Repository, error) {
-	path, err := filepath.Abs(path)
+func Open(repoPath string) (*Repository, error) {
+	repoPath, err := filepath.Abs(repoPath)
 	if err != nil {
 		return nil, err
-	} else if !isDir(path) {
+	} else if !isDir(repoPath) {
 		return nil, os.ErrNotExist
 	}
 
 	return &Repository{
-		path:          path,
+		path:          repoPath,
 		cachedCommits: newObjectCache(),
 		cachedTags:    newObjectCache(),
 	}, nil