Merge "jiri: Clarify the arg to -remote-branch."
diff --git a/doc.go b/doc.go
index 588efd9..0e3a622 100644
--- a/doc.go
+++ b/doc.go
@@ -406,10 +406,6 @@
particular, it can be used to create new snapshots and to list existing
snapshots.
-The command-line flag "-remote" determines whether the command pertains to
-"local" snapshots that are only stored locally or "remote" snapshots the are
-revisioned in the manifest repository.
-
Usage:
jiri snapshot [flags] <command>
@@ -418,6 +414,8 @@
list List existing project snapshots
The jiri snapshot flags are:
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
-remote=false
Manage remote snapshots.
@@ -431,10 +429,8 @@
Jiri snapshot create - Create a new project snapshot
The "jiri snapshot create <label>" command captures the current project state in
-a manifest and, depending on the value of the -remote flag, the command either
-stores the manifest in the local $JIRI_ROOT/.snapshots directory, or in the
-manifest repository, pushing the change to the remote repository and thus making
-it available globally.
+a manifest. If the -push-remote flag is provided, the snapshot is committed and
+pushed upstream.
Internally, snapshots are organized as follows:
@@ -463,11 +459,15 @@
<label> is the snapshot label.
The jiri snapshot create flags are:
+ -push-remote=false
+ Commit and push snapshot upstream.
-time-format=2006-01-02T15:04:05Z07:00
Time format for snapshot file name.
-color=true
Use color to format output.
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
-n=false
Show what commands will run but do not execute them.
-remote=false
@@ -489,6 +489,8 @@
The jiri snapshot list flags are:
-color=true
Use color to format output.
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
-n=false
Show what commands will run but do not execute them.
-remote=false
diff --git a/gitutil/.api b/gitutil/.api
index 8bf6ac4..4ba995e 100644
--- a/gitutil/.api
+++ b/gitutil/.api
@@ -7,6 +7,7 @@
pkg gitutil, method (*Git) BranchesDiffer(string, string) (bool, error)
pkg gitutil, method (*Git) CheckoutBranch(string, ...CheckoutOpt) error
pkg gitutil, method (*Git) Clone(string, string) error
+pkg gitutil, method (*Git) CloneRecursive(string, string) error
pkg gitutil, method (*Git) Commit() error
pkg gitutil, method (*Git) CommitAmend() error
pkg gitutil, method (*Git) CommitAmendWithMessage(string) error
diff --git a/gitutil/git.go b/gitutil/git.go
index 879cabd..82d0c3c 100644
--- a/gitutil/git.go
+++ b/gitutil/git.go
@@ -113,6 +113,11 @@
// Clone clones the given repository to the given local path.
func (g *Git) Clone(repo, path string) error {
+ return g.run("clone", repo, path)
+}
+
+// CloneRecursive clones the given repository recursively to the given local path.
+func (g *Git) CloneRecursive(repo, path string) error {
return g.run("clone", "--recursive", repo, path)
}
diff --git a/jiri/.api b/jiri/.api
index 0addbef..384b799 100644
--- a/jiri/.api
+++ b/jiri/.api
@@ -11,10 +11,6 @@
pkg jiri, method (*X) BinDir() string
pkg jiri, method (*X) Clone(tool.ContextOpts) *X
pkg jiri, method (*X) JiriManifestFile() string
-pkg jiri, method (*X) LocalSnapshotDir() string
-pkg jiri, method (*X) ManifestDir() string
-pkg jiri, method (*X) ManifestFile(string) string
-pkg jiri, method (*X) RemoteSnapshotDir() string
pkg jiri, method (*X) ResolveManifestPath(string) (string, error)
pkg jiri, method (*X) RootMetaDir() string
pkg jiri, method (*X) UpdateHistoryDir() string
diff --git a/jiri/x.go b/jiri/x.go
index 685283c..20133dd 100644
--- a/jiri/x.go
+++ b/jiri/x.go
@@ -136,26 +136,6 @@
return filepath.Join(x.RootMetaDir(), "update_history")
}
-// LocalSnapshotDir returns the path to the local snapshot directory.
-func (x *X) LocalSnapshotDir() string {
- return filepath.Join(x.Root, ".snapshot")
-}
-
-// RemoteSnapshotDir returns the path to the remote snapshot directory.
-func (x *X) RemoteSnapshotDir() string {
- return filepath.Join(x.ManifestDir(), "snapshot")
-}
-
-// ManifestDir returns the path to the manifest directory.
-func (x *X) ManifestDir() string {
- return filepath.Join(x.Root, ".manifest", "v2")
-}
-
-// ManifestFile returns the path to the manifest file with the given name.
-func (x *X) ManifestFile(name string) string {
- return filepath.Join(x.ManifestDir(), name)
-}
-
// ResolveManifestPath resolves the given manifest name to an absolute path in
// the local filesystem.
func (x *X) ResolveManifestPath(name string) (string, error) {
@@ -172,18 +152,19 @@
//
// TODO(toddw): Remove this logic when the transition to .jiri_manifest is done.
func (x *X) resolveManifestPathDeprecated(name string) (string, error) {
+ manifestDir := filepath.Join(x.Root, ".manifest", "v2")
if name != "" {
if filepath.IsAbs(name) {
return name, nil
}
- return x.ManifestFile(name), nil
+ return filepath.Join(manifestDir, name), nil
}
path := filepath.Join(x.Root, ".local_manifest")
switch _, err := os.Stat(path); {
case err == nil:
return path, nil
case os.IsNotExist(err):
- return x.ManifestFile("default"), nil
+ return filepath.Join(manifestDir, "default"), nil
default:
return "", fmt.Errorf("Stat(%v) failed: %v", path, err)
}
diff --git a/jiritest/fake.go b/jiritest/fake.go
index 4987b15..c3e8195 100644
--- a/jiritest/fake.go
+++ b/jiritest/fake.go
@@ -63,7 +63,7 @@
if err := fake.WriteRemoteManifest(&project.Manifest{}); err != nil {
t.Fatal(err)
}
- if err := jirix.Git().Clone(fake.Projects[manifestProject], filepath.Join(jirix.Root, manifestProject)); err != nil {
+ if err := jirix.Git().CloneRecursive(fake.Projects[manifestProject], filepath.Join(jirix.Root, manifestProject)); err != nil {
t.Fatal(err)
}
diff --git a/profiles/profilescmdline/reader_cmdline.go b/profiles/profilescmdline/reader_cmdline.go
index 1573684..2afac17 100644
--- a/profiles/profilescmdline/reader_cmdline.go
+++ b/profiles/profilescmdline/reader_cmdline.go
@@ -28,7 +28,6 @@
// IsFlagSet returns true if the specified flag has been set on
// the command line.
-// TODO(cnicolaou): use this to simplify the implementation of profiles.Target
func IsFlagSet(fs *flag.FlagSet, name string) bool {
found := false
fs.Visit(func(f *flag.Flag) {
@@ -36,7 +35,7 @@
found = true
}
})
- return true
+ return found
}
// NOTE: we use functions to initialize the commands so that we
diff --git a/project/project.go b/project/project.go
index 276aeba..a877633 100644
--- a/project/project.go
+++ b/project/project.go
@@ -1851,7 +1851,12 @@
if found && strings.HasPrefix(op.project.Remote, host.Location) {
gitHookDir := filepath.Join(tmpDir, ".git", "hooks")
for _, githook := range host.GitHooks {
- mdir := jirix.ManifestDir()
+ // TODO(nlacasse): GitHook paths are relative to the manifest
+ // file. Currently all manifests live in
+ // JIRI_ROOT/.manifest/v2, but that is changing. I think
+ // GitHooks should be associated with projects, and their paths
+ // should be relative to the project root.
+ mdir := filepath.Join(jirix.Root, ".manifest", "v2")
src, err := s.ReadFile(filepath.Join(mdir, githook.Path))
if err != nil {
return err
diff --git a/snapshot.go b/snapshot.go
index 1ed9255..3238615 100644
--- a/snapshot.go
+++ b/snapshot.go
@@ -21,14 +21,28 @@
"v.io/x/lib/cmdline"
)
+const (
+ defaultSnapshotDir = ".snapshot"
+)
+
var (
- remoteFlag bool
- timeFormatFlag string
+ snapshotDirFlag string
+ pushRemoteFlag bool
+ timeFormatFlag string
+
+ // TODO(nlacasse): Remove the -remote flag once all users have moved to the
+ // -push-remote flag.
+ remoteFlag bool
)
func init() {
- cmdSnapshot.Flags.BoolVar(&remoteFlag, "remote", false, "Manage remote snapshots.")
+ cmdSnapshot.Flags.StringVar(&snapshotDirFlag, "dir", "", "Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.")
+ cmdSnapshotCreate.Flags.BoolVar(&pushRemoteFlag, "push-remote", false, "Commit and push snapshot upstream.")
cmdSnapshotCreate.Flags.StringVar(&timeFormatFlag, "time-format", time.RFC3339, "Time format for snapshot file name.")
+
+ // TODO(nlacasse): Remove the -remote flag once all users have moved to the
+ // -push-remote flag.
+ cmdSnapshot.Flags.BoolVar(&remoteFlag, "remote", false, "Manage remote snapshots.")
}
var cmdSnapshot = &cmdline.Command{
@@ -38,10 +52,6 @@
The "jiri snapshot" command can be used to manage project snapshots.
In particular, it can be used to create new snapshots and to list
existing snapshots.
-
-The command-line flag "-remote" determines whether the command
-pertains to "local" snapshots that are only stored locally or "remote"
-snapshots the are revisioned in the manifest repository.
`,
Children: []*cmdline.Command{cmdSnapshotCreate, cmdSnapshotList},
}
@@ -52,12 +62,9 @@
Name: "create",
Short: "Create a new project snapshot",
Long: `
-The "jiri snapshot create <label>" command captures the current project
-state in a manifest and, depending on the value of the -remote flag,
-the command either stores the manifest in the local
-$JIRI_ROOT/.snapshots directory, or in the manifest repository, pushing
-the change to the remote repository and thus making it available
-globally.
+The "jiri snapshot create <label>" command captures the current project state
+in a manifest. If the -push-remote flag is provided, the snapshot is committed
+and pushed upstream.
Internally, snapshots are organized as follows:
@@ -94,75 +101,59 @@
return err
}
snapshotFile := filepath.Join(snapshotDir, "labels", label, time.Now().Format(timeFormatFlag))
- // Either atomically create a new snapshot that captures the project
- // state and push the changes to the remote repository (if
- // applicable), or fail with no effect.
+
+ if !remoteFlag && !pushRemoteFlag {
+ // No git operations necessary. Just create the snapshot file.
+ return createSnapshot(jirix, snapshotDir, snapshotFile, label)
+ }
+
+ // Attempt to create a snapshot on a clean master branch. If snapshot
+ // creation fails, return to the state we were in before.
createFn := func() error {
revision, err := jirix.Git().CurrentRevision()
if err != nil {
return err
}
if err := createSnapshot(jirix, snapshotDir, snapshotFile, label); err != nil {
- // Clean up on all errors.
jirix.Git().Reset(revision)
jirix.Git().RemoveUntrackedFiles()
return err
}
- return nil
+ return commitAndPushChanges(jirix, snapshotDir, snapshotFile, label)
}
- // Execute the above function in the snapshot directory.
+ // Execute the above function in the snapshot directory on a clean master branch.
p := project.Project{
Path: snapshotDir,
Protocol: "git",
Revision: "HEAD",
}
- if err := project.ApplyToLocalMaster(jirix, project.Projects{p.Key(): p}, createFn); err != nil {
- return err
- }
- return nil
+ return project.ApplyToLocalMaster(jirix, project.Projects{p.Key(): p}, createFn)
}
-// getSnapshotDir returns the path to the snapshot directory, respecting the
-// value of the "-remote" command-line flag. It performs validation that the
-// directory exists and is initialized.
+// getSnapshotDir returns the path to the snapshot directory, creating it if
+// necessary.
func getSnapshotDir(jirix *jiri.X) (string, error) {
- dir := jirix.LocalSnapshotDir()
+ dir := snapshotDirFlag
+ if dir == "" {
+ dir = filepath.Join(jirix.Root, defaultSnapshotDir)
+ }
+
+ // TODO(nlacasse): Remove once there are no more user of the -remote flag.
if remoteFlag {
- dir = jirix.RemoteSnapshotDir()
+ dir = filepath.Join(jirix.Root, ".manifest", "v2", "snapshot")
}
- s := jirix.NewSeq()
- switch _, err := s.Stat(dir); {
- case err == nil:
- return dir, nil
- case !runutil.IsNotExist(err):
- return "", err
- case remoteFlag:
- if err := s.MkdirAll(dir, 0755).Done(); err != nil {
- return "", err
- }
- return dir, nil
- }
- // Create a new local snapshot directory.
- createFn := func() (e error) {
- if err := s.MkdirAll(dir, 0755).Done(); err != nil {
- return err
- }
- if err := jirix.Git().Init(dir); err != nil {
- return err
- }
+
+ if !filepath.IsAbs(dir) {
cwd, err := os.Getwd()
if err != nil {
- return err
+ return "", err
}
- defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
- if err := s.Chdir(dir).Done(); err != nil {
- return err
- }
- return jirix.Git().Commit()
+ dir = filepath.Join(cwd, dir)
}
- if err := createFn(); err != nil {
- s.RemoveAll(dir)
+
+ // Make sure directory exists.
+ if err := jirix.NewSeq().MkdirAll(dir, 0755).Done(); err != nil {
return "", err
}
return dir, nil
@@ -181,23 +172,15 @@
symlink := filepath.Join(snapshotDir, label)
newSymlink := symlink + ".new"
relativeSnapshotPath := strings.TrimPrefix(snapshotFile, snapshotDir+string(os.PathSeparator))
- if err := s.RemoveAll(newSymlink).
+ return s.RemoveAll(newSymlink).
Symlink(relativeSnapshotPath, newSymlink).
- Rename(newSymlink, symlink).Done(); err != nil {
- return err
- }
-
- // Revision the changes.
- if err := revisionChanges(jirix, snapshotDir, snapshotFile, label); err != nil {
- return err
- }
- return nil
+ Rename(newSymlink, symlink).Done()
}
-// revisionChanges commits changes identified by the given manifest
-// file and label to the manifest repository and (if applicable)
-// pushes these changes to the remote repository.
-func revisionChanges(jirix *jiri.X, snapshotDir, snapshotFile, label string) (e error) {
+// commitAndPushChanges commits changes identified by the given manifest file
+// and label to the containing repository and pushes these changes to the
+// remote repository.
+func commitAndPushChanges(jirix *jiri.X, snapshotDir, snapshotFile, label string) (e error) {
cwd, err := os.Getwd()
if err != nil {
return err
@@ -217,10 +200,8 @@
if err := jirix.Git().CommitWithMessage(fmt.Sprintf("adding snapshot %q for label %q", name, label)); err != nil {
return err
}
- if remoteFlag {
- if err := jirix.Git().Push("origin", "master", gitutil.VerifyOpt(false)); err != nil {
- return err
- }
+ if err := jirix.Git().Push("origin", "master", gitutil.VerifyOpt(false)); err != nil {
+ return err
}
return nil
}
diff --git a/snapshot_test.go b/snapshot_test.go
index 8bbcf1a..7fb99d1 100644
--- a/snapshot_test.go
+++ b/snapshot_test.go
@@ -11,6 +11,7 @@
"path/filepath"
"testing"
+ "v.io/jiri/gitutil"
"v.io/jiri/jiri"
"v.io/jiri/jiritest"
"v.io/jiri/project"
@@ -18,6 +19,9 @@
)
func createLabelDir(t *testing.T, jirix *jiri.X, snapshotDir, name string, snapshots []string) {
+ if snapshotDir == "" {
+ snapshotDir = filepath.Join(jirix.Root, defaultSnapshotDir)
+ }
s := jirix.NewSeq()
labelDir, perm := filepath.Join(snapshotDir, "labels", name), os.FileMode(0700)
if err := s.MkdirAll(labelDir, perm).Done(); err != nil {
@@ -60,21 +64,20 @@
}
func TestList(t *testing.T) {
+ resetFlags()
fake, cleanup := jiritest.NewFakeJiriRoot(t)
defer cleanup()
- remoteSnapshotDir := fake.X.RemoteSnapshotDir()
- localSnapshotDir := fake.X.LocalSnapshotDir()
+ snapshotDir1 := "" // Should use default dir.
+ snapshotDir2 := filepath.Join(fake.X.Root, "some/other/dir")
// Create a test suite.
tests := []config{
config{
- remote: false,
- dir: localSnapshotDir,
+ dir: snapshotDir1,
},
config{
- remote: true,
- dir: remoteSnapshotDir,
+ dir: snapshotDir2,
},
}
labels := []label{
@@ -89,7 +92,7 @@
}
for _, test := range tests {
- remoteFlag = test.remote
+ snapshotDirFlag = test.dir
// Create the snapshots directory and populate it with the
// data specified by the test suite.
for _, label := range labels {
@@ -174,7 +177,187 @@
}
}
+func resetFlags() {
+ snapshotDirFlag = ""
+ pushRemoteFlag = false
+ remoteFlag = false
+}
+
+func TestGetSnapshotDir(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+
+ // With all flags at default values, snapshot dir should be default.
+ resetFlags()
+ got, err := getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := filepath.Join(fake.X.Root, defaultSnapshotDir); got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+
+ // With remote flag set, snapshot dir should be JIRI_ROOT/.manifest/v2/snapshot.
+ resetFlags()
+ remoteFlag = true
+ got, err = getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := filepath.Join(fake.X.Root, ".manifest", "v2", "snapshot"); got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+
+ // With dir flag set to absolute path, snapshot dir should be value of dir
+ // flag.
+ resetFlags()
+ tempDir, err := fake.X.NewSeq().TempDir("", "")
+ if err != nil {
+ t.Fatalf("TempDir() failed: %v", err)
+ }
+ defer fake.X.NewSeq().RemoveAll(tempDir).Done()
+ snapshotDirFlag = tempDir
+ got, err = getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := snapshotDirFlag; got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+
+ // With dir flag set to relative path, snapshot dir should absolute path
+ // rooted at current working dir.
+ resetFlags()
+ snapshotDirFlag = "some/relative/path"
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("os.Getwd() failed: %v", err)
+ }
+ got, err = getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := filepath.Join(cwd, snapshotDirFlag); got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+}
+
+// TestCreate tests creating and checking out a snapshot.
func TestCreate(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+
+ // Setup the initial remote and local projects.
+ numProjects, remoteProjects := 2, []string{}
+ for i := 0; i < numProjects; i++ {
+ if err := fake.CreateRemoteProject(remoteProjectName(i)); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := fake.AddProject(project.Project{
+ Name: remoteProjectName(i),
+ Path: localProjectName(i),
+ Remote: fake.Projects[remoteProjectName(i)],
+ }); err != nil {
+ t.Fatalf("%v", err)
+ }
+ }
+
+ // Create initial commits in the remote projects and use UpdateUniverse()
+ // to mirror them locally.
+ for i := 0; i < numProjects; i++ {
+ writeReadme(t, fake.X, fake.Projects[remoteProjectName(i)], "revision 1")
+ }
+ if err := project.UpdateUniverse(fake.X, true); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Create a snapshot.
+ var stdout bytes.Buffer
+ fake.X.Context = tool.NewContext(tool.ContextOpts{Stdout: &stdout})
+ if err := runSnapshotCreate(fake.X, []string{"test-local"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Remove the local project repositories.
+ for i, _ := range remoteProjects {
+ localProject := filepath.Join(fake.X.Root, localProjectName(i))
+ if err := s.RemoveAll(localProject).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ }
+
+ // Check that invoking the UpdateUniverse() with the snapshot restores the
+ // local repositories.
+ snapshotDir := filepath.Join(fake.X.Root, defaultSnapshotDir)
+ snapshotFile := filepath.Join(snapshotDir, "test-local")
+ localX := fake.X.Clone(tool.ContextOpts{
+ Manifest: &snapshotFile,
+ })
+ if err := project.UpdateUniverse(localX, true); err != nil {
+ t.Fatalf("%v", err)
+ }
+ for i, _ := range remoteProjects {
+ localProject := filepath.Join(fake.X.Root, localProjectName(i))
+ checkReadme(t, fake.X, localProject, "revision 1")
+ }
+}
+
+// TestCreatePushRemote checks that creating a snapshot with the -push-remote
+// flag causes the snapshot to be committed and pushed upstream.
+func TestCreatePushRemote(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
+
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+
+ fake.EnableRemoteManifestPush()
+ defer fake.DisableRemoteManifestPush()
+
+ manifestDir := filepath.Join(fake.X.Root, ".manifest")
+ snapshotDir := filepath.Join(manifestDir, "snapshot")
+ label := "test"
+
+ git := gitutil.New(fake.X.NewSeq(), manifestDir)
+ commitCount, err := git.CountCommits("master", "")
+ if err != nil {
+ t.Fatalf("git.CountCommits(\"master\", \"\") failed: %v", err)
+ }
+
+ // Create snapshot with -push-remote flag set to true.
+ snapshotDirFlag = snapshotDir
+ pushRemoteFlag = true
+ if err := runSnapshotCreate(fake.X, []string{label}); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Check that repo has one new commit.
+ newCommitCount, err := git.CountCommits("master", "")
+ if err != nil {
+ t.Fatalf("git.CountCommits(\"master\", \"\") failed: %v", err)
+ }
+ if got, want := newCommitCount, commitCount+1; got != want {
+ t.Errorf("unexpected commit count: got %v want %v", got, want)
+ }
+
+ // Check that new label is commited.
+ labelFile := filepath.Join(snapshotDir, "labels", label)
+ if !git.IsFileCommitted(labelFile) {
+ t.Errorf("expected file %v to be committed but it was not", labelFile)
+ }
+}
+
+// TestCreateDeprecated tests "local" and "remote" snapshot creation.
+// TODO(nlacasse): Delete this test once the old -remote flag has been removed.
+// The new snapshot behavior is tested in TestCreate and TestCreatePushRemote.
+func TestCreateDeprecated(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
fake, cleanup := jiritest.NewFakeJiriRoot(t)
defer cleanup()
s := fake.X.NewSeq()
@@ -221,7 +404,7 @@
// Check that invoking the UpdateUniverse() with the local
// snapshot restores the local repositories.
- snapshotDir := fake.X.LocalSnapshotDir()
+ snapshotDir := filepath.Join(fake.X.Root, defaultSnapshotDir)
snapshotFile := filepath.Join(snapshotDir, "test-local")
localX := fake.X.Clone(tool.ContextOpts{
Manifest: &snapshotFile,
