| // Copyright 2015 The Vanadium 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 ( |
| "os" |
| "path/filepath" |
| "sort" |
| "strings" |
| "testing" |
| |
| "go.fuchsia.dev/jiri/gitutil" |
| "go.fuchsia.dev/jiri/jiritest" |
| "go.fuchsia.dev/jiri/project" |
| ) |
| |
| func setDefaultRunpFlags() { |
| runpFlags.projectKeys = "" |
| runpFlags.verbose = false |
| runpFlags.interactive = false |
| runpFlags.uncommitted = false |
| runpFlags.untracked = false |
| runpFlags.noUncommitted = false |
| runpFlags.noUntracked = false |
| runpFlags.showNamePrefix = false |
| runpFlags.showPathPrefix = false |
| runpFlags.showKeyPrefix = false |
| runpFlags.exitOnError = false |
| runpFlags.collateOutput = true |
| runpFlags.branch = "" |
| runpFlags.remote = "" |
| } |
| |
| func addProjects(t *testing.T, fake *jiritest.FakeJiriRoot) []*project.Project { |
| projects := []*project.Project{} |
| for _, name := range []string{"a", "b", "c", "t1", "t2"} { |
| projectPath := "r." + name |
| if name == "t1" { |
| projectPath = "sub/" + projectPath |
| } |
| if name == "t2" { |
| projectPath = "sub/sub2/" + projectPath |
| } |
| if err := fake.CreateRemoteProject(projectPath); err != nil { |
| t.Fatalf("%v", err) |
| } |
| p := project.Project{ |
| Name: projectPath, |
| Path: filepath.Join(fake.X.Root, projectPath), |
| Remote: fake.Projects[projectPath], |
| RemoteBranch: "master", |
| } |
| if err := fake.AddProject(p); err != nil { |
| t.Fatalf("%v", err) |
| } |
| projects = append(projects, &p) |
| } |
| if err := fake.UpdateUniverse(false); err != nil { |
| t.Fatalf("%v", err) |
| } |
| return projects |
| } |
| |
| func executeRunp(t *testing.T, fake *jiritest.FakeJiriRoot, args ...string) string { |
| stderr := "" |
| runCmd := func() { |
| if err := runRunp(fake.X, args); err != nil { |
| stderr = err.Error() |
| } |
| } |
| stdout, _, err := runfunc(runCmd) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return strings.TrimSpace(strings.Join([]string{stdout, stderr}, " ")) |
| } |
| |
| func TestRunP(t *testing.T) { |
| fake, cleanup := jiritest.NewFakeJiriRoot(t) |
| defer cleanup() |
| projects := addProjects(t, fake) |
| |
| if got, want := len(projects), 5; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| cwd, err := os.Getwd() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer os.Chdir(cwd) |
| |
| chdir := func(dir string) { |
| if err := os.Chdir(dir); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| manifestKey := strings.Replace(string(projects[0].Key()), "r.a", "manifest", -1) |
| manifestPath := strings.Replace(projects[0].Path, "r.a", "manifest", -1) |
| keys := []string{manifestKey} |
| paths := []string{manifestPath} |
| for _, p := range projects { |
| keys = append(keys, string(p.Key())) |
| paths = append(paths, p.Path) |
| } |
| |
| chdir(projects[0].Path) |
| setDefaultRunpFlags() |
| runpFlags.showNamePrefix = true |
| runpFlags.verbose = true |
| got := executeRunp(t, fake, "echo") |
| hdr := "Project Names: manifest r.a r.b r.c sub/r.t1 sub/sub2/r.t2\n" |
| hdr += "Project Keys: " + strings.Join(keys, " ") + "\n" |
| |
| if want := hdr + "manifest: \nr.a: \nr.b: \nr.c: \nsub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.interactive = false |
| got = executeRunp(t, fake, "git", "rev-parse", "--abbrev-ref", "HEAD") |
| if want := "HEAD\nHEAD\nHEAD\nHEAD\nHEAD\nHEAD"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.showKeyPrefix = true |
| runpFlags.interactive = false |
| got = executeRunp(t, fake, "git", "rev-parse", "--abbrev-ref", "HEAD") |
| if want := strings.Join(keys, ": HEAD\n") + ": HEAD"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.showNamePrefix = true |
| runpFlags.interactive = false |
| runpFlags.collateOutput = false |
| uncollated := executeRunp(t, fake, "git", "rev-parse", "--abbrev-ref", "HEAD") |
| split := strings.Split(uncollated, "\n") |
| sort.Strings(split) |
| got = strings.TrimSpace(strings.Join(split, "\n")) |
| if want := "manifest: HEAD\nr.a: HEAD\nr.b: HEAD\nr.c: HEAD\nsub/r.t1: HEAD\nsub/sub2/r.t2: HEAD"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.showPathPrefix = true |
| got = executeRunp(t, fake, "git", "rev-parse", "--abbrev-ref", "HEAD") |
| if want := strings.Join(paths, ": HEAD\n") + ": HEAD"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.projectKeys = "r.t[12]" |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "sub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| rb := projects[1].Path |
| rc := projects[2].Path |
| t1 := projects[3].Path |
| |
| newfile := func(dir, file string) { |
| testfile := filepath.Join(dir, file) |
| _, err := os.Create(testfile) |
| if err != nil { |
| t.Errorf("failed to create %s: %v", testfile, err) |
| } |
| } |
| |
| git := func(dir string) *gitutil.Git { |
| return gitutil.New(fake.X, gitutil.RootDirOpt(dir)) |
| } |
| |
| newfile(rb, "untracked.go") |
| setDefaultRunpFlags() |
| runpFlags.untracked = true |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "r.b:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.noUntracked = true |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "manifest: \nr.a: \nr.c: \nsub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| newfile(rc, "uncommitted.go") |
| |
| if err := git(rc).Add("uncommitted.go"); err != nil { |
| t.Error(err) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.uncommitted = true |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "r.c:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| setDefaultRunpFlags() |
| runpFlags.noUncommitted = true |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "manifest: \nr.a: \nr.b: \nsub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| newfile(rc, "untracked.go") |
| setDefaultRunpFlags() |
| runpFlags.uncommitted = true |
| runpFlags.untracked = true |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "r.c:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| git(rb).CreateAndCheckoutBranch("a1") |
| git(rb).CreateAndCheckoutBranch("b2") |
| git(rc).CreateAndCheckoutBranch("b2") |
| git(t1).CreateAndCheckoutBranch("a1") |
| |
| chdir(rc) |
| |
| // Just the projects with branch b2. |
| setDefaultRunpFlags() |
| runpFlags.showNamePrefix = true |
| runpFlags.branch = "b2" |
| got = executeRunp(t, fake, "echo") |
| if want := "r.b: \nr.c:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| // Show all prjects even though current project is on b2 |
| setDefaultRunpFlags() |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "manifest: \nr.a: \nr.b: \nr.c: \nsub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| // All projects since --projects takes precendence over branches. |
| setDefaultRunpFlags() |
| runpFlags.projectKeys = ".*" |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "manifest: \nr.a: \nr.b: \nr.c: \nsub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| |
| if err := os.MkdirAll(filepath.Join(rb, ".jiri", "a1"), os.FileMode(0755)); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Just the projects with remotes containing "sub". |
| setDefaultRunpFlags() |
| runpFlags.remote = "sub" |
| runpFlags.showNamePrefix = true |
| got = executeRunp(t, fake, "echo") |
| if want := "sub/r.t1: \nsub/sub2/r.t2:"; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| } |
