blob: 34772d04efcf560ea82e6abd9388b65e91b131f7 [file] [log] [blame]
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"bytes"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"testing"
)
const lenChangeId = len("\n\nChange-Id: I") + 2*20
func TestHookCommitMsg(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
// Check that hook adds Change-Id.
write(t, gt.client+"/msg.txt", "Test message.\n")
testMain(t, "hook-invoke", "commit-msg", gt.client+"/msg.txt")
data, err := ioutil.ReadFile(gt.client + "/msg.txt")
if err != nil {
t.Fatal(err)
}
if !bytes.Contains(data, []byte("\n\nChange-Id: ")) {
t.Fatalf("after hook-invoke commit-msg, missing Change-Id:\n%s", data)
}
// Check that hook is no-op when Change-Id is already present.
testMain(t, "hook-invoke", "commit-msg", gt.client+"/msg.txt")
data1, err := ioutil.ReadFile(gt.client + "/msg.txt")
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(data, data1) {
t.Fatalf("second hook-invoke commit-msg changed Change-Id:\nbefore:\n%s\n\nafter:\n%s", data, data1)
}
// Check that hook fails when message is empty.
write(t, gt.client+"/empty.txt", "\n\n# just a file with\n# comments\n")
testMainDied(t, "hook-invoke", "commit-msg", gt.client+"/empty.txt")
const want = "git-codereview: empty commit message\n"
if got := testStderr.String(); got != want {
t.Fatalf("unexpected output:\ngot: %q\nwant: %q", got, want)
}
// Check that hook inserts a blank line after the first line as needed.
rewrites := []struct {
in string
want string
}{
{in: "all: gofmt", want: "all: gofmt"},
{in: "all: gofmt\n", want: "all: gofmt\n"},
{in: "all: gofmt\nahhh", want: "all: gofmt\n\nahhh"},
{in: "all: gofmt\n\nahhh", want: "all: gofmt\n\nahhh"},
{in: "all: gofmt\n\n\nahhh", want: "all: gofmt\n\n\nahhh"},
}
for _, tt := range rewrites {
write(t, gt.client+"/in.txt", tt.in)
testMain(t, "hook-invoke", "commit-msg", gt.client+"/in.txt")
write(t, gt.client+"/want.txt", tt.want)
testMain(t, "hook-invoke", "commit-msg", gt.client+"/want.txt")
got, err := ioutil.ReadFile(gt.client + "/in.txt")
if err != nil {
t.Fatal(err)
}
want, err := ioutil.ReadFile(gt.client + "/want.txt")
if err != nil {
t.Fatal(err)
}
// pull off the Change-Id that got appended
got = got[:len(got)-lenChangeId]
want = want[:len(want)-lenChangeId]
if !bytes.Equal(got, want) {
t.Fatalf("failed to rewrite:\n%s\n\ngot:\n\n%s\n\nwant:\n\n%s\n", tt.in, got, want)
}
}
}
func TestHookCommitMsgIssueRepoRewrite(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
// If there's no config, don't rewrite issue references.
const msg = "math/big: catch all the rats\n\nFixes #99999, at least for now\n"
write(t, gt.client+"/msg.txt", msg)
testMain(t, "hook-invoke", "commit-msg", gt.client+"/msg.txt")
got, err := ioutil.ReadFile(gt.client + "/msg.txt")
if err != nil {
t.Fatal(err)
}
got = got[:len(got)-lenChangeId]
if string(got) != msg {
t.Errorf("hook changed %s to %s", msg, got)
}
// Add issuerepo config.
write(t, gt.client+"/codereview.cfg", "issuerepo: golang/go")
trun(t, gt.client, "git", "add", "codereview.cfg")
trun(t, gt.client, "git", "commit", "-m", "add issuerepo codereview config")
// Look in master rather than origin/master for the config
savedConfigRef := configRef
configRef = "master:codereview.cfg"
cachedConfig = nil
// Check for the rewrite
write(t, gt.client+"/msg.txt", msg)
testMain(t, "hook-invoke", "commit-msg", gt.client+"/msg.txt")
got, err = ioutil.ReadFile(gt.client + "/msg.txt")
if err != nil {
t.Fatal(err)
}
got = got[:len(got)-lenChangeId]
const want = "math/big: catch all the rats\n\nFixes golang/go#99999, at least for now\n"
if string(got) != want {
t.Errorf("issue rewrite failed: got\n\n%s\nwant\n\n%s", got, want)
}
// Reset config state
configRef = savedConfigRef
cachedConfig = nil
}
func TestHookCommitMsgBranchPrefix(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
checkPrefix := func(prefix string) {
write(t, gt.client+"/msg.txt", "Test message.\n")
testMain(t, "hook-invoke", "commit-msg", gt.client+"/msg.txt")
data, err := ioutil.ReadFile(gt.client + "/msg.txt")
if err != nil {
t.Fatal(err)
}
if !bytes.HasPrefix(data, []byte(prefix)) {
t.Errorf("after hook-invoke commit-msg on %s, want prefix %q:\n%s", CurrentBranch().Name, prefix, data)
}
if i := strings.Index(prefix, "]"); i >= 0 {
prefix := prefix[:i+1]
for _, magic := range []string{"fixup!", "squash!"} {
write(t, gt.client+"/msg.txt", magic+" Test message.\n")
testMain(t, "hook-invoke", "commit-msg", gt.client+"/msg.txt")
data, err := ioutil.ReadFile(gt.client + "/msg.txt")
if err != nil {
t.Fatal(err)
}
if bytes.HasPrefix(data, []byte(prefix)) {
t.Errorf("after hook-invoke commit-msg on %s with %s, found incorrect prefix %q:\n%s", CurrentBranch().Name, magic, prefix, data)
}
}
}
}
// Create server branch and switch to server branch on client.
// Test that commit hook adds prefix.
trun(t, gt.server, "git", "checkout", "-b", "dev.cc")
trun(t, gt.client, "git", "fetch", "-q")
testMain(t, "change", "dev.cc")
checkPrefix("[dev.cc] Test message.\n")
// Work branch with server branch as upstream.
testMain(t, "change", "ccwork")
checkPrefix("[dev.cc] Test message.\n")
// Master has no prefix.
testMain(t, "change", "master")
checkPrefix("Test message.\n")
// Work branch from master has no prefix.
testMain(t, "change", "work")
checkPrefix("Test message.\n")
}
func TestHookPreCommit(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
// Write out a non-Go file.
testMain(t, "change", "mybranch")
write(t, gt.client+"/msg.txt", "A test message.")
trun(t, gt.client, "git", "add", "msg.txt")
testMain(t, "hook-invoke", "pre-commit") // should be no-op
if err := os.MkdirAll(gt.client+"/test/bench", 0755); err != nil {
t.Fatal(err)
}
write(t, gt.client+"/bad.go", badGo)
write(t, gt.client+"/good.go", goodGo)
write(t, gt.client+"/test/bad.go", badGo)
write(t, gt.client+"/test/good.go", goodGo)
write(t, gt.client+"/test/bench/bad.go", badGo)
write(t, gt.client+"/test/bench/good.go", goodGo)
trun(t, gt.client, "git", "add", ".")
testMainDied(t, "hook-invoke", "pre-commit")
testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):",
"bad.go", "!good.go", fromSlash("!test/bad"), fromSlash("test/bench/bad.go"))
write(t, gt.client+"/broken.go", brokenGo)
trun(t, gt.client, "git", "add", "broken.go")
testMainDied(t, "hook-invoke", "pre-commit")
testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):",
"bad.go", "!good.go", fromSlash("!test/bad"), fromSlash("test/bench/bad.go"),
"gofmt reported errors:", "broken.go")
}
func TestHookChangeGofmt(t *testing.T) {
// During git change, we run the gofmt check before invoking commit,
// so we should not see the line about 'git commit' failing.
// That is, the failure should come from git change, not from
// the commit hook.
gt := newGitTest(t)
defer gt.done()
gt.work(t)
// Write out a non-Go file.
write(t, gt.client+"/bad.go", badGo)
trun(t, gt.client, "git", "add", ".")
t.Logf("invoking commit hook explicitly")
testMainDied(t, "hook-invoke", "pre-commit")
testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):", "bad.go")
t.Logf("change without hook installed")
testCommitMsg = "foo: msg"
testMainDied(t, "change")
testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):", "bad.go", "!running: git")
t.Logf("change with hook installed")
restore := testInstallHook(t, gt)
defer restore()
testCommitMsg = "foo: msg"
testMainDied(t, "change")
testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):", "bad.go", "!running: git")
}
func TestHookPreCommitDetachedHead(t *testing.T) {
// If we're in detached head mode, something special is going on,
// like git rebase. We disable the gofmt-checking precommit hook,
// since we expect it would just get in the way at that point.
// (It also used to crash.)
gt := newGitTest(t)
defer gt.done()
gt.work(t)
write(t, gt.client+"/bad.go", badGo)
trun(t, gt.client, "git", "add", ".")
trun(t, gt.client, "git", "checkout", "HEAD^0")
testMain(t, "hook-invoke", "pre-commit")
testNoStdout(t)
testNoStderr(t)
}
func TestHookPreCommitEnv(t *testing.T) {
// If $GIT_GOFMT_HOOK == "off", gofmt hook should not complain.
gt := newGitTest(t)
defer gt.done()
gt.work(t)
write(t, gt.client+"/bad.go", badGo)
trun(t, gt.client, "git", "add", ".")
os.Setenv("GIT_GOFMT_HOOK", "off")
defer os.Unsetenv("GIT_GOFMT_HOOK")
testMain(t, "hook-invoke", "pre-commit")
testNoStdout(t)
testPrintedStderr(t, "git-gofmt-hook disabled by $GIT_GOFMT_HOOK=off")
}
func TestHookPreCommitUnstaged(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
gt.work(t)
write(t, gt.client+"/bad.go", badGo)
write(t, gt.client+"/good.go", goodGo)
// The pre-commit hook is being asked about files in the index.
// Make sure it is not looking at files in the working tree (current directory) instead.
// There are three possible kinds of file: good, bad (misformatted), and broken (syntax error).
// There are also three possible places files live: the most recent commit, the index,
// and the working tree. We write a sequence of files that cover all possible
// combination of kinds of file in the various places. For example,
// good-bad-broken.go is a good file in the most recent commit,
// a bad file in the index, and a broken file in the working tree.
// After creating these files, we check that the gofmt hook reports
// about the index only.
const N = 3
name := []string{"good", "bad", "broken"}
content := []string{goodGo, badGo, brokenGo}
var wantErr []string
var allFiles []string
writeFiles := func(n int) {
allFiles = nil
wantErr = nil
for i := 0; i < N*N*N; i++ {
// determine n'th digit of 3-digit base-N value i
j := i
for k := 0; k < (3 - 1 - n); k++ {
j /= N
}
file := fmt.Sprintf("%s-%s-%s.go", name[i/N/N], name[(i/N)%N], name[i%N])
allFiles = append(allFiles, file)
write(t, gt.client+"/"+file, content[j%N])
switch {
case strings.Contains(file, "-bad-"):
wantErr = append(wantErr, "\t"+file+"\n")
case strings.Contains(file, "-broken-"):
wantErr = append(wantErr, "\t"+file+":")
default:
wantErr = append(wantErr, "!"+file)
}
}
}
// committed files
writeFiles(0)
trun(t, gt.client, "git", "add", ".")
trun(t, gt.client, "git", "commit", "-m", "msg")
// staged files
writeFiles(1)
trun(t, gt.client, "git", "add", ".")
// unstaged files
writeFiles(2)
wantErr = append(wantErr, "gofmt reported errors", "gofmt needs to format these files")
testMainDied(t, "hook-invoke", "pre-commit")
testPrintedStderr(t, wantErr...)
}
func TestHooks(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
gt.removeStubHooks()
testMain(t, "hooks") // install hooks
data, err := ioutil.ReadFile(gt.client + "/.git/hooks/commit-msg")
if err != nil {
t.Fatalf("hooks did not write commit-msg hook: %v", err)
}
if string(data) != "#!/bin/sh\nexec git-codereview hook-invoke commit-msg \"$@\"\n" {
t.Fatalf("invalid commit-msg hook:\n%s", string(data))
}
}
func TestHooksOverwriteOldCommitMsg(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
write(t, gt.client+"/.git/hooks/commit-msg", oldCommitMsgHook)
testMain(t, "hooks") // install hooks
data, err := ioutil.ReadFile(gt.client + "/.git/hooks/commit-msg")
if err != nil {
t.Fatalf("hooks did not write commit-msg hook: %v", err)
}
if string(data) == oldCommitMsgHook {
t.Fatalf("hooks left old commit-msg hook in place")
}
if string(data) != "#!/bin/sh\nexec git-codereview hook-invoke commit-msg \"$@\"\n" {
t.Fatalf("invalid commit-msg hook:\n%s", string(data))
}
}
func testInstallHook(t *testing.T, gt *gitTest) (restore func()) {
trun(t, gt.pwd, "go", "build", "-o", gt.client+"/git-codereview")
path := os.Getenv("PATH")
os.Setenv("PATH", gt.client+string(filepath.ListSeparator)+path)
gt.removeStubHooks()
testMain(t, "hooks") // install hooks
return func() {
os.Setenv("PATH", path)
}
}
func TestHookCommitMsgFromGit(t *testing.T) {
gt := newGitTest(t)
defer gt.done()
restore := testInstallHook(t, gt)
defer restore()
testMain(t, "change", "mybranch")
write(t, gt.client+"/file", "more data")
trun(t, gt.client, "git", "add", "file")
trun(t, gt.client, "git", "commit", "-m", "mymsg")
log := trun(t, gt.client, "git", "log", "-n", "1")
if !strings.Contains(log, "mymsg") {
t.Fatalf("did not find mymsg in git log output:\n%s", log)
}
// The 4 spaces are because git indents the commit message proper.
if !strings.Contains(log, "\n \n Change-Id:") {
t.Fatalf("did not find Change-Id in git log output:\n%s", log)
}
}