func TestRound(t *testing.T) { t.Parallel() ut.AssertEqual(t, 1500*time.Millisecond, round(1549*time.Millisecond, 100*time.Millisecond)) ut.AssertEqual(t, 1600*time.Millisecond, round(1550*time.Millisecond, 100*time.Millisecond)) ut.AssertEqual(t, -1500*time.Millisecond, round(-1549*time.Millisecond, 100*time.Millisecond)) ut.AssertEqual(t, -1600*time.Millisecond, round(-1550*time.Millisecond, 100*time.Millisecond)) }
func TestConfigYAMLBadMode(t *testing.T) { data, err := yaml.Marshal("foo") ut.AssertEqual(t, nil, err) v := PreCommit ut.AssertEqual(t, errors.New("invalid mode \"foo\""), yaml.Unmarshal(data, &v)) ut.AssertEqual(t, PreCommit, v) }
func TestChangIgnore(t *testing.T) { t.Parallel() c := newChange(&dummyRepo{t, "<root>"}, nil, nil, IgnorePatterns{"*.pb.go"}) ut.AssertEqual(t, false, c.IsIgnored("foo.go")) ut.AssertEqual(t, true, c.IsIgnored("foo.pb.go")) ut.AssertEqual(t, true, c.IsIgnored("bar/foo.pb.go")) }
func setup(t *testing.T, tmpDir string) { _, code, err := internal.Capture(tmpDir, nil, "git", "init") ut.AssertEqual(t, 0, code) ut.AssertEqual(t, nil, err) run(t, tmpDir, nil, "config", "user.email", "nobody@localhost") run(t, tmpDir, nil, "config", "user.name", "nobody") }
func TestConfigYAML(t *testing.T) { config := New("0.1") data, err := yaml.Marshal(config) ut.AssertEqual(t, nil, err) actual := &Config{} ut.AssertEqual(t, nil, yaml.Unmarshal(data, actual)) ut.AssertEqual(t, config, actual) }
func TestGetRepoNoRepo(t *testing.T) { t.Parallel() tmpDir, err := ioutil.TempDir("", "pre-commit-go") defer func() { if err := internal.RemoveAll(tmpDir); err != nil { t.Errorf("%s", err) } }() r, err := GetRepo(tmpDir, "") ut.AssertEqual(t, errors.New("failed to find git checkout root"), err) ut.AssertEqual(t, nil, r) }
func TestCoveragePrerequisites(t *testing.T) { // This test can't be parallel. if !IsContinuousIntegration() { old := os.Getenv("CI") defer func() { ut.ExpectEqual(t, nil, os.Setenv("CI", old)) }() ut.AssertEqual(t, nil, os.Setenv("CI", "true")) ut.AssertEqual(t, true, IsContinuousIntegration()) } c := Coverage{UseCoveralls: true} ut.AssertEqual(t, 1, len(c.GetPrerequisites())) }
func run(t *testing.T, tmpDir string, env []string, args ...string) string { internal := &git{root: tmpDir} out, code, err := internal.captureEnv(env, args...) ut.AssertEqualf(t, 0, code, "%s", out) ut.AssertEqual(t, nil, err) return out }
func assertHEAD(t *testing.T, r ReadOnlyRepo, expected Commit) Commit { if head := r.Eval(string(Head)); head != expected { t.Logf("%s", strings.Join(os.Environ(), "\n")) t.Logf("%s", run(t, r.Root(), nil, "log", "-p", "--format=fuller")) ut.AssertEqual(t, expected, head) } return expected }
func TestChecksDescriptions(t *testing.T) { t.Parallel() for _, name := range getKnownChecks() { c := KnownChecks[name]() ut.AssertEqual(t, true, c.GetDescription() != "") c.GetPrerequisites() } }
func TestCustom(t *testing.T) { t.Parallel() p := []CheckPrerequisite{ { HelpCommand: []string{"go", "version"}, ExpectedExitCode: 0, URL: "example.com.local", }, } c := &Custom{ Description: "foo", Command: []string{"go", "version"}, Prerequisites: p, } ut.AssertEqual(t, "foo", c.GetDescription()) ut.AssertEqual(t, p, c.GetPrerequisites()) }
func TestRemoveAllMissing(t *testing.T) { td, err := ioutil.TempDir("", "pre-commit-go") ut.ExpectEqual(t, nil, err) foo := filepath.Join(td, "foo") err = ioutil.WriteFile(foo, []byte("yo"), 0600) ut.ExpectEqual(t, nil, err) ut.AssertEqual(t, nil, RemoveAll(td)) }
func TestRangeToString(t *testing.T) { t.Parallel() ut.AssertEqual(t, "", rangeToString(nil)) ut.AssertEqual(t, "1", rangeToString([]int{1})) ut.AssertEqual(t, "1-2", rangeToString([]int{1, 2})) ut.AssertEqual(t, "1-3", rangeToString([]int{1, 2, 3})) ut.AssertEqual(t, "1,3-4,6-8", rangeToString([]int{1, 3, 4, 6, 7, 8})) ut.AssertEqual(t, "1,3-4,6", rangeToString([]int{1, 3, 4, 6})) }
func TestChecksSuccess(t *testing.T) { // Runs all checks, they should all pass. t.Parallel() if testing.Short() { t.SkipNow() } td, err := ioutil.TempDir("", "pre-commit-go") ut.AssertEqual(t, nil, err) defer func() { if err := internal.RemoveAll(td); err != nil { t.Fail() } }() change := setup(t, td, goodFiles) for _, name := range getKnownChecks() { c := KnownChecks[name]() switch name { case "custom": c = &Custom{ Description: "foo", Command: []string{"go", "version"}, CheckExitCode: true, Prerequisites: []CheckPrerequisite{ { HelpCommand: []string{"go", "version"}, ExpectedExitCode: 0, URL: "example.com.local", }, }, } case "copyright": cop := c.(*Copyright) cop.Header = "// Foo" case "coverage": cov := c.(*Coverage) cov.Global.MinCoverage = 100 cov.Global.MaxCoverage = 100 cov.PerDirDefault.MinCoverage = 100 cov.PerDirDefault.MaxCoverage = 100 } if l, ok := c.(sync.Locker); ok { l.Lock() l.Unlock() } if err := c.Run(change, &Options{MaxDuration: 1}); err != nil { t.Errorf("%s failed: %s", c.GetName(), err) } } }
func setup(t *testing.T, td string, files map[string]string) scm.Change { fooDir := filepath.Join(td, "src", "foo") ut.AssertEqual(t, nil, os.MkdirAll(fooDir, 0700)) for f, c := range files { p := filepath.Join(fooDir, f) ut.AssertEqual(t, nil, os.MkdirAll(filepath.Dir(p), 0700)) ut.AssertEqual(t, nil, ioutil.WriteFile(p, []byte(c), 0600)) } _, code, err := internal.Capture(fooDir, nil, "git", "init") ut.AssertEqual(t, 0, code) ut.AssertEqual(t, nil, err) // It's important to add the files to the index, otherwise they will be // ignored. _, code, err = internal.Capture(fooDir, nil, "git", "add", ".") ut.AssertEqual(t, 0, code) ut.AssertEqual(t, nil, err) repo, err := scm.GetRepo(fooDir, td) ut.AssertEqual(t, nil, err) change, err := repo.Between(scm.Current, scm.GitInitialCommit, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, true, change != nil) return change }
func TestConfigNew(t *testing.T) { config := New("0.1") ut.AssertEqual(t, 3, len(config.Modes[PreCommit].Checks)) ut.AssertEqual(t, 3, len(config.Modes[PrePush].Checks)) ut.AssertEqual(t, 5, len(config.Modes[ContinuousIntegration].Checks)) ut.AssertEqual(t, 3, len(config.Modes[Lint].Checks)) checks, options := config.EnabledChecks([]Mode{PreCommit, PrePush, ContinuousIntegration, Lint}) ut.AssertEqual(t, Options{MaxDuration: 120}, *options) ut.AssertEqual(t, 2+4+5+3, len(checks)) }
// makeTree creates a temporary directory and creates the files in it. // // Returns the root directly, all files created and the cleanup function. func makeTree(t *testing.T, files map[string]string) (string, []string, func()) { td, err := ioutil.TempDir("", "pre-commit-go") ut.AssertEqual(t, nil, err) cleanup := func() { if err := internal.RemoveAll(td); err != nil { t.Fail() } } allFiles := make([]string, 0, len(files)) for f, c := range files { allFiles = append(allFiles, f) p := filepath.Join(td, f) if err := os.MkdirAll(filepath.Dir(p), 0700); err != nil { cleanup() t.Fatal(err) } if err := ioutil.WriteFile(p, []byte(c), 0600); err != nil { cleanup() t.Fatal(err) } } sort.Strings(allFiles) return td, allFiles, cleanup }
func TestCoverageGlobal(t *testing.T) { t.Parallel() if testing.Short() { t.SkipNow() } td, err := ioutil.TempDir("", "pre-commit-go") ut.AssertEqual(t, nil, err) defer func() { if err := internal.RemoveAll(td); err != nil { t.Fail() } }() change := setup(t, td, coverageFiles) c := &Coverage{ UseGlobalInference: true, UseCoveralls: false, Global: CoverageSettings{ MinCoverage: 50, MaxCoverage: 100, }, PerDirDefault: CoverageSettings{ MinCoverage: 50, MaxCoverage: 100, }, PerDir: map[string]*CoverageSettings{}, } profile, err := c.RunProfile(change, &Options{MaxDuration: 1}) ut.AssertEqual(t, nil, err) expected := CoverageProfile{ { Source: "foo.go", Line: 3, SourceRef: "foo.go:3", Name: "Type.Foo", Covered: 2, Missing: []int{}, Total: 2, Percent: 100, }, { Source: "bar/bar.go", Line: 2, SourceRef: "bar/bar.go:2", Name: "Bar", Covered: 2, Missing: []int{7, 8}, Total: 4, Percent: 50, }, { Source: "bar/bar.go", Line: 11, SourceRef: "bar/bar.go:11", Name: "Baz", Covered: 2, Missing: []int{16, 17}, Total: 4, Percent: 50, }, } ut.AssertEqual(t, expected, profile) ut.AssertEqual(t, 60., profile.CoveragePercent()) ut.AssertEqual(t, 2, profile.PartiallyCoveredFuncs()) expected = CoverageProfile{ { Source: "bar.go", Line: 2, SourceRef: "bar/bar.go:2", Name: "Bar", Covered: 2, Missing: []int{7, 8}, Total: 4, Percent: 50, }, { Source: "bar.go", Line: 11, SourceRef: "bar/bar.go:11", Name: "Baz", Covered: 2, Missing: []int{16, 17}, Total: 4, Percent: 50, }, } ut.AssertEqual(t, expected, profile.Subset("bar")) expected = CoverageProfile{ { Source: "foo.go", Line: 3, SourceRef: "foo.go:3", Name: "Type.Foo", Covered: 2, Missing: []int{}, Total: 2, Percent: 100, }, } ut.AssertEqual(t, expected, profile.Subset(".")) }
func TestGetRepoGitSlowFailures(t *testing.T) { t.Parallel() tmpDir, err := ioutil.TempDir("", "pre-commit-go") defer func() { if err := internal.RemoveAll(tmpDir); err != nil { t.Errorf("%s", err) } }() setup(t, tmpDir) r, err := getRepo(tmpDir, tmpDir) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, tmpDir, r.Root()) // Remove the .git directory after calling GetRepo(). ut.AssertEqual(t, nil, internal.RemoveAll(filepath.Join(tmpDir, ".git"))) p, err := r.HookPath() ut.AssertEqual(t, errors.New("failed to find .git dir: failed to find .git dir: failed to run \"git rev-parse --git-dir\""), err) ut.AssertEqual(t, "", p) ut.AssertEqual(t, []string(nil), r.untracked()) ut.AssertEqual(t, []string(nil), r.unstaged()) ut.AssertEqual(t, Commit(gitInitial), r.Eval(string(Head))) ut.AssertEqual(t, "", r.Ref(Head)) done, err := r.Stash() ut.AssertEqual(t, errors.New("failed to get list of untracked files"), err) ut.AssertEqual(t, false, done) errStr := r.Restore().Error() if errStr != "git reset failed:\nfatal: Not a git repository: '.git'" && errStr != "git reset failed:\nfatal: Not a git repository (or any of the parent directories): .git" { t.Fatalf("Unexpected error: %s", errStr) } errStr = r.Checkout(string(Initial)).Error() if errStr != "checkout failed:\nfatal: Not a git repository: '.git'" && errStr != "checkout failed:\nfatal: Not a git repository (or any of the parent directories): .git" { t.Fatalf("Unexpected error: %s", errStr) } }
func TestCheckPrerequisite(t *testing.T) { // Runs all checks, they should all pass. t.Parallel() ut.AssertEqual(t, true, (&CheckPrerequisite{HelpCommand: []string{"go", "version"}, ExpectedExitCode: 0}).IsPresent()) ut.AssertEqual(t, false, (&CheckPrerequisite{HelpCommand: []string{"go", "version"}, ExpectedExitCode: 1}).IsPresent()) }
func TestChangeAll(t *testing.T) { // All packages were affected, uses a slightly different (faster) code path. t.Parallel() if testing.Short() { t.SkipNow() } root, allFiles, cleanup := makeTree(t, map[string]string{ "bar/bar.go": "package bar\nfunc Bar() int { return 1}", "bar/bar_test.go": "package bar", "foo/foo.go": "package foo\nfunc Foo() int { return 42}", "main.go": "package main\nimport \"foo\"\nfunc main() { foo.Foo() }", "main_test.go": "package main", }) defer cleanup() r := &dummyRepo{t, root} c := newChange(r, []string{"bar/bar.go", "foo/foo.go", "main.go"}, allFiles, nil) ut.AssertEqual(t, r, c.Repo()) ut.AssertEqual(t, "", c.Package()) changed := c.Changed() ut.AssertEqual(t, []string{"bar/bar.go", "foo/foo.go", "main.go"}, changed.GoFiles()) ut.AssertEqual(t, []string{".", "./bar", "./foo"}, changed.Packages()) ut.AssertEqual(t, []string{".", "./bar"}, changed.TestPackages()) indirect := c.Indirect() ut.AssertEqual(t, []string{"bar/bar.go", "foo/foo.go", "main.go"}, indirect.GoFiles()) ut.AssertEqual(t, []string{".", "./bar", "./foo"}, indirect.Packages()) ut.AssertEqual(t, []string{".", "./bar"}, indirect.TestPackages()) all := c.All() ut.AssertEqual(t, []string{"bar/bar.go", "bar/bar_test.go", "foo/foo.go", "main.go", "main_test.go"}, all.GoFiles()) ut.AssertEqual(t, []string{".", "./bar", "./foo"}, all.Packages()) ut.AssertEqual(t, []string{".", "./bar"}, all.TestPackages()) }
func TestInternalCheck(t *testing.T) { t.Parallel() d, err := os.Getwd() ut.AssertEqual(t, nil, err) ut.AssertEqual(t, "scm", filepath.Base(d)) }
func TestChangeIndirectReverse(t *testing.T) { // a_test.go is indirectly affect by z/z.go. Make sure the order files are // processed in does not affect the result. t.Parallel() if testing.Short() { t.SkipNow() } root, allFiles, cleanup := makeTree(t, map[string]string{ // Is changed. "z/z.go": "package z\nfunc Bar() int { return 1}", // Directly affected. "z/z_test.go": "package z", // Indirectly affected. "y/y.go": "package y\nimport \"z\"\nfunc Bar() int { return z.Bar() }", // Not affected. "x/x.go": "package x\nfunc Foo() { return 42 }", // Indirectly affected by "y". "x/x_test.go": "package x\nimport (\n\"y\"\n\"testing\"\n)\nfunc TestFoo(t *testing.T) int { if y.Bar() != 1 { t.FailNow() } }", // Not affected even if it imports "x". "w/w.go": "package w\nimport \"x\"\nfunc Foo() { return x.Foo() }", // Indirectly affected by "b". "a_test.go": "package main\nimport \"y\"\nfunc main() { println(y.Bar()) }", }) defer cleanup() r := &dummyRepo{t, root} c := newChange(r, []string{"z/z.go"}, allFiles, nil) ut.AssertEqual(t, r, c.Repo()) ut.AssertEqual(t, "", c.Package()) changed := c.Changed() ut.AssertEqual(t, []string{"z/z.go"}, changed.GoFiles()) ut.AssertEqual(t, []string{"./z"}, changed.Packages()) ut.AssertEqual(t, []string{"./z"}, changed.TestPackages()) indirect := c.Indirect() ut.AssertEqual(t, []string{"z/z.go"}, indirect.GoFiles()) ut.AssertEqual(t, []string{"./y", "./z"}, indirect.Packages()) ut.AssertEqual(t, []string{".", "./x", "./z"}, indirect.TestPackages()) all := c.All() ut.AssertEqual(t, allFiles, all.GoFiles()) ut.AssertEqual(t, []string{".", "./w", "./x", "./y", "./z"}, all.Packages()) ut.AssertEqual(t, []string{".", "./x", "./z"}, all.TestPackages()) }
func TestCoverageEmpty(t *testing.T) { t.Parallel() ut.AssertEqual(t, 0., CoverageProfile{}.CoveragePercent()) c := Coverage{PerDir: map[string]*CoverageSettings{"foo": nil}} ut.AssertEqual(t, &CoverageSettings{}, c.SettingsForPkg("foo")) }
func TestGetRepoGitSlowSuccess(t *testing.T) { // Make a repository and test behavior against it. t.Parallel() if isDrone() { t.Skipf("Give up on drone, it uses a weird go template which makes it not standard when using git init") } tmpDir, err := ioutil.TempDir("", "pre-commit-go") defer func() { if err := internal.RemoveAll(tmpDir); err != nil { t.Errorf("%s", err) } }() setup(t, tmpDir) r, err := getRepo(tmpDir, tmpDir) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, tmpDir, r.Root()) p, err := r.HookPath() ut.AssertEqual(t, nil, err) ut.AssertEqual(t, filepath.Join(tmpDir, ".git", "hooks"), p) ut.AssertEqual(t, Commit(gitInitial), r.Eval(string(Head))) ut.AssertEqual(t, nil, err) err = r.Checkout(string(Initial)) ut.AssertEqual(t, errors.New("checkout failed:\nfatal: Cannot switch branch to a non-commit '4b825dc642cb6eb9a060e54bf8d69288fbee4904'"), err) ut.AssertEqual(t, []string{}, r.untracked()) ut.AssertEqual(t, []string{}, r.unstaged()) write(t, tmpDir, "src/foo/file1.go", "package foo\n") check(t, r, []string{"src/foo/file1.go"}, []string{}) run(t, tmpDir, nil, "add", "src/foo/file1.go") check(t, r, []string{}, []string{}) done, err := r.Stash() ut.AssertEqual(t, nil, err) ut.AssertEqual(t, false, done) write(t, tmpDir, "src/foo/file1.go", "package foo\n// hello\n") check(t, r, []string{}, []string{"src/foo/file1.go"}) done, err = r.Stash() ut.AssertEqual(t, errors.New("Can't stash until there's at least one commit"), err) ut.AssertEqual(t, false, done) deterministicCommit(t, tmpDir) ut.AssertEqual(t, "master", r.Ref(Head)) ut.AssertEqual(t, "package foo\n// hello\n", read(t, tmpDir, "src/foo/file1.go")) commitInitial := assertHEAD(t, r, "f4edb8ac30289340040451b6f8c20d17614a9ae7") ut.AssertEqual(t, "master", r.Ref(Head)) done, err = r.Stash() ut.AssertEqual(t, nil, err) ut.AssertEqual(t, true, done) ut.AssertEqual(t, "package foo\n", read(t, tmpDir, "src/foo/file1.go")) ut.AssertEqual(t, nil, r.Restore()) ut.AssertEqual(t, "package foo\n// hello\n", read(t, tmpDir, "src/foo/file1.go")) msg := "checkout failed:\nerror: pathspec 'invalid' did not match any file(s) known to git." ut.AssertEqual(t, errors.New(msg), r.Checkout("invalid")) ut.AssertEqual(t, "package foo\n// hello\n", read(t, tmpDir, "src/foo/file1.go")) ut.AssertEqual(t, "master", r.Ref(Head)) ut.AssertEqual(t, nil, r.Checkout(string(commitInitial))) ut.AssertEqual(t, "package foo\n", read(t, tmpDir, "src/foo/file1.go")) ut.AssertEqual(t, commitInitial, r.Eval(string(Head))) ut.AssertEqual(t, nil, r.Checkout("master")) ut.AssertEqual(t, "package foo\n", read(t, tmpDir, "src/foo/file1.go")) ut.AssertEqual(t, "master", r.Ref(Head)) ut.AssertEqual(t, commitInitial, r.Eval(string(Head))) ut.AssertEqual(t, Invalid, r.Eval(string(Upstream))) ut.AssertEqual(t, Invalid, r.Eval("HEAD~1000")) c, err := r.Between(commitInitial, Initial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.Changed().GoFiles()) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.Indirect().GoFiles()) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.All().GoFiles()) c, err = r.Between(Current, Initial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.Changed().GoFiles()) c, err = r.Between(Current, Initial, []string{"f*"}) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, nil, c) c, err = r.Between(Current, commitInitial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, nil, c) c, err = r.Between(commitInitial, Current, nil) ut.AssertEqual(t, errors.New("can't use Current as old commit"), err) ut.AssertEqual(t, nil, c) c, err = r.Between(commitInitial, Commit("foo"), nil) ut.AssertEqual(t, errors.New("invalid old commit"), err) ut.AssertEqual(t, nil, c) // Add a file then remove it. Make sure the file doesn't show up. check(t, r, []string{}, []string{}) write(t, tmpDir, "src/foo/deleted/deleted.go", "package deleted\n") ut.AssertEqual(t, []string{}, r.staged()) run(t, tmpDir, nil, "add", "src/foo/deleted/deleted.go") ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go"}, r.staged()) deterministicCommit(t, tmpDir) commitWithDeleted := assertHEAD(t, r, "c9b5f312ec8eefb58beeaf8c3684bb832fdefef7") c, err = r.Between(commitWithDeleted, Initial, nil) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.Changed().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.Indirect().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.All().GoFiles()) c, err = r.Between(commitWithDeleted, commitInitial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go"}, c.Changed().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go"}, c.Indirect().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.All().GoFiles()) ut.AssertEqual(t, nil, err) // Do the delete. run(t, tmpDir, nil, "rm", "src/foo/deleted/deleted.go") ut.AssertEqual(t, []string{}, r.staged()) deterministicCommit(t, tmpDir) commitAfterDelete := assertHEAD(t, r, "8aacb7c27c4d012c56bd861d2a8bc4da8ea7ee73") c, err = r.Between(commitAfterDelete, Initial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.Changed().GoFiles()) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.Indirect().GoFiles()) ut.AssertEqual(t, []string{"src/foo/file1.go"}, c.All().GoFiles()) c, err = r.Between(commitAfterDelete, commitWithDeleted, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, nil, c) c, err = r.Between(commitWithDeleted, Initial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.Changed().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.Indirect().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.All().GoFiles()) c, err = r.Between(commitWithDeleted, commitInitial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go"}, c.Changed().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go"}, c.Indirect().GoFiles()) ut.AssertEqual(t, []string{"src/foo/deleted/deleted.go", "src/foo/file1.go"}, c.All().GoFiles()) c, err = r.Between(Current, commitInitial, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, nil, c) c, err = r.Between(Current, commitAfterDelete, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, nil, c) c, err = r.Between(Current, commitWithDeleted, nil) ut.AssertEqual(t, nil, err) ut.AssertEqual(t, nil, c) }
func read(t *testing.T, tmpDir, name string) string { content, err := ioutil.ReadFile(filepath.Join(tmpDir, name)) ut.AssertEqual(t, nil, err) return string(content) }
func write(t *testing.T, tmpDir, name string, content string) { if d := filepath.Dir(name); d != "" { ut.AssertEqual(t, nil, os.MkdirAll(filepath.Join(tmpDir, d), 0700)) } ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(tmpDir, name), []byte(content), 0600)) }
func TestChangeEmpty(t *testing.T) { t.Parallel() r := &dummyRepo{t, "<root>"} files := []string{} allFiles := []string{} c := newChange(r, files, allFiles, nil) ut.AssertEqual(t, r, c.Repo()) ut.AssertEqual(t, "", c.Package()) changed := c.Changed() ut.AssertEqual(t, []string(nil), changed.GoFiles()) ut.AssertEqual(t, []string(nil), changed.Packages()) ut.AssertEqual(t, []string(nil), changed.TestPackages()) indirect := c.Indirect() ut.AssertEqual(t, []string(nil), indirect.GoFiles()) ut.AssertEqual(t, []string(nil), indirect.Packages()) ut.AssertEqual(t, []string(nil), indirect.TestPackages()) all := c.All() ut.AssertEqual(t, []string(nil), all.GoFiles()) ut.AssertEqual(t, []string(nil), all.Packages()) ut.AssertEqual(t, []string(nil), all.TestPackages()) }
func TestChangeIndirect(t *testing.T) { // main_test.go is indirectly affect by a/A.go. t.Parallel() if testing.Short() { t.SkipNow() } root, allFiles, cleanup := makeTree(t, map[string]string{ // Is changed. "a/a.go": "package a\nfunc Bar() int { return 1}", // Directly affected. "a/a_test.go": "package a", // Indirectly affected. "b/b.go": "package b\nimport \"a\"\nfunc Bar() int { return a.Bar() }", // Not affected. "c/c.go": "package c\nfunc Foo() { return 42 }", // Indirectly affected by "b". "c/c_test.go": "package c\nimport (\n\"b\"\n\"testing\"\n)\nfunc TestFoo(t *testing.T) int { if b.Bar() != 1 { t.FailNow() } }", // Not affected even if it imports "c". "d/d.go": "package d\nimport \"c\"\nfunc Foo() { return c.Foo() }", // Indirectly affected by "b". "main_test.go": "package main\nimport \"b\"\nfunc main() { println(b.Bar()) }", }) defer cleanup() r := &dummyRepo{t, root} c := newChange(r, []string{"a/a.go"}, allFiles, nil) ut.AssertEqual(t, r, c.Repo()) ut.AssertEqual(t, "", c.Package()) changed := c.Changed() ut.AssertEqual(t, []string{"a/a.go"}, changed.GoFiles()) ut.AssertEqual(t, []string{"./a"}, changed.Packages()) ut.AssertEqual(t, []string{"./a"}, changed.TestPackages()) indirect := c.Indirect() ut.AssertEqual(t, []string{"a/a.go"}, indirect.GoFiles()) ut.AssertEqual(t, []string{"./a", "./b"}, indirect.Packages()) ut.AssertEqual(t, []string{".", "./a", "./c"}, indirect.TestPackages()) all := c.All() ut.AssertEqual(t, allFiles, all.GoFiles()) ut.AssertEqual(t, []string{".", "./a", "./b", "./c", "./d"}, all.Packages()) ut.AssertEqual(t, []string{".", "./a", "./c"}, all.TestPackages()) }
func check(t *testing.T, r repo, untracked []string, unstaged []string) { ut.AssertEqual(t, untracked, r.untracked()) ut.AssertEqual(t, unstaged, r.unstaged()) }