vendor files

vendor/k8s.io/kubernetes/pkg/volume/git_repo/BUILD

@@ -0,0 +1,54 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "git_repo.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/volume/git_repo",
+    deps = [
+        "//pkg/util/strings:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["git_repo_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/volume/git_repo",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/empty_dir:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+        "//vendor/k8s.io/utils/exec/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/volume/git_repo/OWNERS

@@ -0,0 +1,9 @@
+approvers:
+- thockin
+- saad-ali
+reviewers:
+- saad-ali
+- jsafrane
+- rootfs
+- jingxu97
+- msau42

vendor/k8s.io/kubernetes/pkg/volume/git_repo/doc.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package git_repo contains the internal representation of git repo volumes.
+package git_repo // import "k8s.io/kubernetes/pkg/volume/git_repo"

vendor/k8s.io/kubernetes/pkg/volume/git_repo/git_repo.go

@@ -0,0 +1,278 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package git_repo
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path"
+	"strings"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	utilstrings "k8s.io/kubernetes/pkg/util/strings"
+	"k8s.io/kubernetes/pkg/volume"
+	volumeutil "k8s.io/kubernetes/pkg/volume/util"
+	"k8s.io/utils/exec"
+)
+
+// This is the primary entrypoint for volume plugins.
+func ProbeVolumePlugins() []volume.VolumePlugin {
+	return []volume.VolumePlugin{&gitRepoPlugin{nil}}
+}
+
+type gitRepoPlugin struct {
+	host volume.VolumeHost
+}
+
+var _ volume.VolumePlugin = &gitRepoPlugin{}
+
+func wrappedVolumeSpec() volume.Spec {
+	return volume.Spec{
+		Volume: &v1.Volume{VolumeSource: v1.VolumeSource{EmptyDir: &v1.EmptyDirVolumeSource{}}},
+	}
+}
+
+const (
+	gitRepoPluginName = "kubernetes.io/git-repo"
+)
+
+func (plugin *gitRepoPlugin) Init(host volume.VolumeHost) error {
+	plugin.host = host
+	return nil
+}
+
+func (plugin *gitRepoPlugin) GetPluginName() string {
+	return gitRepoPluginName
+}
+
+func (plugin *gitRepoPlugin) GetVolumeName(spec *volume.Spec) (string, error) {
+	volumeSource, _ := getVolumeSource(spec)
+	if volumeSource == nil {
+		return "", fmt.Errorf("Spec does not reference a Git repo volume type")
+	}
+
+	return fmt.Sprintf(
+		"%v:%v:%v",
+		volumeSource.Repository,
+		volumeSource.Revision,
+		volumeSource.Directory), nil
+}
+
+func (plugin *gitRepoPlugin) CanSupport(spec *volume.Spec) bool {
+	return spec.Volume != nil && spec.Volume.GitRepo != nil
+}
+
+func (plugin *gitRepoPlugin) RequiresRemount() bool {
+	return false
+}
+
+func (plugin *gitRepoPlugin) SupportsMountOption() bool {
+	return false
+}
+
+func (plugin *gitRepoPlugin) SupportsBulkVolumeVerification() bool {
+	return false
+}
+
+func (plugin *gitRepoPlugin) NewMounter(spec *volume.Spec, pod *v1.Pod, opts volume.VolumeOptions) (volume.Mounter, error) {
+	return &gitRepoVolumeMounter{
+		gitRepoVolume: &gitRepoVolume{
+			volName: spec.Name(),
+			podUID:  pod.UID,
+			plugin:  plugin,
+		},
+		pod:      *pod,
+		source:   spec.Volume.GitRepo.Repository,
+		revision: spec.Volume.GitRepo.Revision,
+		target:   spec.Volume.GitRepo.Directory,
+		exec:     exec.New(),
+		opts:     opts,
+	}, nil
+}
+
+func (plugin *gitRepoPlugin) NewUnmounter(volName string, podUID types.UID) (volume.Unmounter, error) {
+	return &gitRepoVolumeUnmounter{
+		&gitRepoVolume{
+			volName: volName,
+			podUID:  podUID,
+			plugin:  plugin,
+		},
+	}, nil
+}
+
+func (plugin *gitRepoPlugin) ConstructVolumeSpec(volumeName, mountPath string) (*volume.Spec, error) {
+	gitVolume := &v1.Volume{
+		Name: volumeName,
+		VolumeSource: v1.VolumeSource{
+			GitRepo: &v1.GitRepoVolumeSource{},
+		},
+	}
+	return volume.NewSpecFromVolume(gitVolume), nil
+}
+
+// gitRepo volumes are directories which are pre-filled from a git repository.
+// These do not persist beyond the lifetime of a pod.
+type gitRepoVolume struct {
+	volName string
+	podUID  types.UID
+	plugin  *gitRepoPlugin
+	volume.MetricsNil
+}
+
+var _ volume.Volume = &gitRepoVolume{}
+
+func (gr *gitRepoVolume) GetPath() string {
+	name := gitRepoPluginName
+	return gr.plugin.host.GetPodVolumeDir(gr.podUID, utilstrings.EscapeQualifiedNameForDisk(name), gr.volName)
+}
+
+// gitRepoVolumeMounter builds git repo volumes.
+type gitRepoVolumeMounter struct {
+	*gitRepoVolume
+
+	pod      v1.Pod
+	source   string
+	revision string
+	target   string
+	exec     exec.Interface
+	opts     volume.VolumeOptions
+}
+
+var _ volume.Mounter = &gitRepoVolumeMounter{}
+
+func (b *gitRepoVolumeMounter) GetAttributes() volume.Attributes {
+	return volume.Attributes{
+		ReadOnly:        false,
+		Managed:         true,
+		SupportsSELinux: true, // xattr change should be okay, TODO: double check
+	}
+}
+
+// Checks prior to mount operations to verify that the required components (binaries, etc.)
+// to mount the volume are available on the underlying node.
+// If not, it returns an error
+func (b *gitRepoVolumeMounter) CanMount() error {
+	return nil
+}
+
+// SetUp creates new directory and clones a git repo.
+func (b *gitRepoVolumeMounter) SetUp(fsGroup *int64) error {
+	return b.SetUpAt(b.GetPath(), fsGroup)
+}
+
+// SetUpAt creates new directory and clones a git repo.
+func (b *gitRepoVolumeMounter) SetUpAt(dir string, fsGroup *int64) error {
+	if volumeutil.IsReady(b.getMetaDir()) {
+		return nil
+	}
+
+	// Wrap EmptyDir, let it do the setup.
+	wrapped, err := b.plugin.host.NewWrapperMounter(b.volName, wrappedVolumeSpec(), &b.pod, b.opts)
+	if err != nil {
+		return err
+	}
+	if err := wrapped.SetUpAt(dir, fsGroup); err != nil {
+		return err
+	}
+
+	args := []string{"clone", b.source}
+
+	if len(b.target) != 0 {
+		args = append(args, b.target)
+	}
+	if output, err := b.execCommand("git", args, dir); err != nil {
+		return fmt.Errorf("failed to exec 'git %s': %s: %v",
+			strings.Join(args, " "), output, err)
+	}
+
+	files, err := ioutil.ReadDir(dir)
+	if err != nil {
+		return err
+	}
+
+	if len(b.revision) == 0 {
+		// Done!
+		volumeutil.SetReady(b.getMetaDir())
+		return nil
+	}
+
+	var subdir string
+
+	switch {
+	case b.target == ".":
+		// if target dir is '.', use the current dir
+		subdir = path.Join(dir)
+	case len(files) == 1:
+		// if target is not '.', use the generated folder
+		subdir = path.Join(dir, files[0].Name())
+	default:
+		// if target is not '.', but generated many files, it's wrong
+		return fmt.Errorf("unexpected directory contents: %v", files)
+	}
+
+	if output, err := b.execCommand("git", []string{"checkout", b.revision}, subdir); err != nil {
+		return fmt.Errorf("failed to exec 'git checkout %s': %s: %v", b.revision, output, err)
+	}
+	if output, err := b.execCommand("git", []string{"reset", "--hard"}, subdir); err != nil {
+		return fmt.Errorf("failed to exec 'git reset --hard': %s: %v", output, err)
+	}
+
+	volume.SetVolumeOwnership(b, fsGroup)
+
+	volumeutil.SetReady(b.getMetaDir())
+	return nil
+}
+
+func (b *gitRepoVolumeMounter) getMetaDir() string {
+	return path.Join(b.plugin.host.GetPodPluginDir(b.podUID, utilstrings.EscapeQualifiedNameForDisk(gitRepoPluginName)), b.volName)
+}
+
+func (b *gitRepoVolumeMounter) execCommand(command string, args []string, dir string) ([]byte, error) {
+	cmd := b.exec.Command(command, args...)
+	cmd.SetDir(dir)
+	return cmd.CombinedOutput()
+}
+
+// gitRepoVolumeUnmounter cleans git repo volumes.
+type gitRepoVolumeUnmounter struct {
+	*gitRepoVolume
+}
+
+var _ volume.Unmounter = &gitRepoVolumeUnmounter{}
+
+// TearDown simply deletes everything in the directory.
+func (c *gitRepoVolumeUnmounter) TearDown() error {
+	return c.TearDownAt(c.GetPath())
+}
+
+// TearDownAt simply deletes everything in the directory.
+func (c *gitRepoVolumeUnmounter) TearDownAt(dir string) error {
+	return volume.UnmountViaEmptyDir(dir, c.plugin.host, c.volName, wrappedVolumeSpec(), c.podUID)
+}
+
+func getVolumeSource(spec *volume.Spec) (*v1.GitRepoVolumeSource, bool) {
+	var readOnly bool
+	var volumeSource *v1.GitRepoVolumeSource
+
+	if spec.Volume != nil && spec.Volume.GitRepo != nil {
+		volumeSource = spec.Volume.GitRepo
+		readOnly = spec.ReadOnly
+	}
+
+	return volumeSource, readOnly
+}

vendor/k8s.io/kubernetes/pkg/volume/git_repo/git_repo_test.go

@@ -0,0 +1,384 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package git_repo
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"reflect"
+	"strings"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/empty_dir"
+	volumetest "k8s.io/kubernetes/pkg/volume/testing"
+	"k8s.io/utils/exec"
+	fakeexec "k8s.io/utils/exec/testing"
+)
+
+func newTestHost(t *testing.T) (string, volume.VolumeHost) {
+	tempDir, err := ioutil.TempDir("/tmp", "git_repo_test.")
+	if err != nil {
+		t.Fatalf("can't make a temp rootdir: %v", err)
+	}
+	return tempDir, volumetest.NewFakeVolumeHost(tempDir, nil, empty_dir.ProbeVolumePlugins())
+}
+
+func TestCanSupport(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	tempDir, host := newTestHost(t)
+	defer os.RemoveAll(tempDir)
+	plugMgr.InitPlugins(ProbeVolumePlugins(), nil /* prober */, host)
+
+	plug, err := plugMgr.FindPluginByName("kubernetes.io/git-repo")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	if plug.GetPluginName() != "kubernetes.io/git-repo" {
+		t.Errorf("Wrong name: %s", plug.GetPluginName())
+	}
+	if !plug.CanSupport(&volume.Spec{Volume: &v1.Volume{VolumeSource: v1.VolumeSource{GitRepo: &v1.GitRepoVolumeSource{}}}}) {
+		t.Errorf("Expected true")
+	}
+}
+
+// Expected command
+type expectedCommand struct {
+	// The git command
+	cmd []string
+	// The dir of git command is executed
+	dir string
+}
+
+func TestPlugin(t *testing.T) {
+	gitUrl := "https://github.com/kubernetes/kubernetes.git"
+	revision := "2a30ce65c5ab586b98916d83385c5983edd353a1"
+
+	scenarios := []struct {
+		name              string
+		vol               *v1.Volume
+		expecteds         []expectedCommand
+		isExpectedFailure bool
+	}{
+		{
+			name: "target-dir",
+			vol: &v1.Volume{
+				Name: "vol1",
+				VolumeSource: v1.VolumeSource{
+					GitRepo: &v1.GitRepoVolumeSource{
+						Repository: gitUrl,
+						Revision:   revision,
+						Directory:  "target_dir",
+					},
+				},
+			},
+			expecteds: []expectedCommand{
+				{
+					cmd: []string{"git", "clone", gitUrl, "target_dir"},
+					dir: "",
+				},
+				{
+					cmd: []string{"git", "checkout", revision},
+					dir: "/target_dir",
+				},
+				{
+					cmd: []string{"git", "reset", "--hard"},
+					dir: "/target_dir",
+				},
+			},
+			isExpectedFailure: false,
+		},
+		{
+			name: "target-dir-no-revision",
+			vol: &v1.Volume{
+				Name: "vol1",
+				VolumeSource: v1.VolumeSource{
+					GitRepo: &v1.GitRepoVolumeSource{
+						Repository: gitUrl,
+						Directory:  "target_dir",
+					},
+				},
+			},
+			expecteds: []expectedCommand{
+				{
+					cmd: []string{"git", "clone", gitUrl, "target_dir"},
+					dir: "",
+				},
+			},
+			isExpectedFailure: false,
+		},
+		{
+			name: "only-git-clone",
+			vol: &v1.Volume{
+				Name: "vol1",
+				VolumeSource: v1.VolumeSource{
+					GitRepo: &v1.GitRepoVolumeSource{
+						Repository: gitUrl,
+					},
+				},
+			},
+			expecteds: []expectedCommand{
+				{
+					cmd: []string{"git", "clone", gitUrl},
+					dir: "",
+				},
+			},
+			isExpectedFailure: false,
+		},
+		{
+			name: "no-target-dir",
+			vol: &v1.Volume{
+				Name: "vol1",
+				VolumeSource: v1.VolumeSource{
+					GitRepo: &v1.GitRepoVolumeSource{
+						Repository: gitUrl,
+						Revision:   revision,
+						Directory:  "",
+					},
+				},
+			},
+			expecteds: []expectedCommand{
+				{
+					cmd: []string{"git", "clone", gitUrl},
+					dir: "",
+				},
+				{
+					cmd: []string{"git", "checkout", revision},
+					dir: "/kubernetes",
+				},
+				{
+					cmd: []string{"git", "reset", "--hard"},
+					dir: "/kubernetes",
+				},
+			},
+			isExpectedFailure: false,
+		},
+		{
+			name: "current-dir",
+			vol: &v1.Volume{
+				Name: "vol1",
+				VolumeSource: v1.VolumeSource{
+					GitRepo: &v1.GitRepoVolumeSource{
+						Repository: gitUrl,
+						Revision:   revision,
+						Directory:  ".",
+					},
+				},
+			},
+			expecteds: []expectedCommand{
+				{
+					cmd: []string{"git", "clone", gitUrl, "."},
+					dir: "",
+				},
+				{
+					cmd: []string{"git", "checkout", revision},
+					dir: "",
+				},
+				{
+					cmd: []string{"git", "reset", "--hard"},
+					dir: "",
+				},
+			},
+			isExpectedFailure: false,
+		},
+	}
+
+	for _, scenario := range scenarios {
+		allErrs := doTestPlugin(scenario, t)
+		if len(allErrs) == 0 && scenario.isExpectedFailure {
+			t.Errorf("Unexpected success for scenario: %s", scenario.name)
+		}
+		if len(allErrs) > 0 && !scenario.isExpectedFailure {
+			t.Errorf("Unexpected failure for scenario: %s - %+v", scenario.name, allErrs)
+		}
+	}
+
+}
+
+func doTestPlugin(scenario struct {
+	name              string
+	vol               *v1.Volume
+	expecteds         []expectedCommand
+	isExpectedFailure bool
+}, t *testing.T) []error {
+	allErrs := []error{}
+
+	plugMgr := volume.VolumePluginMgr{}
+	rootDir, host := newTestHost(t)
+	defer os.RemoveAll(rootDir)
+	plugMgr.InitPlugins(ProbeVolumePlugins(), nil /* prober */, host)
+
+	plug, err := plugMgr.FindPluginByName("kubernetes.io/git-repo")
+	if err != nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("Can't find the plugin by name"))
+		return allErrs
+	}
+	pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{UID: types.UID("poduid")}}
+	mounter, err := plug.NewMounter(volume.NewSpecFromVolume(scenario.vol), pod, volume.VolumeOptions{})
+
+	if err != nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("Failed to make a new Mounter: %v", err))
+		return allErrs
+	}
+	if mounter == nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("Got a nil Mounter"))
+		return allErrs
+	}
+
+	path := mounter.GetPath()
+	suffix := fmt.Sprintf("pods/poduid/volumes/kubernetes.io~git-repo/%v", scenario.vol.Name)
+	if !strings.HasSuffix(path, suffix) {
+		allErrs = append(allErrs,
+			fmt.Errorf("Got unexpected path: %s", path))
+		return allErrs
+	}
+
+	// Test setUp()
+	setUpErrs := doTestSetUp(scenario, mounter)
+	allErrs = append(allErrs, setUpErrs...)
+
+	if _, err := os.Stat(path); err != nil {
+		if os.IsNotExist(err) {
+			allErrs = append(allErrs,
+				fmt.Errorf("SetUp() failed, volume path not created: %s", path))
+			return allErrs
+		} else {
+			allErrs = append(allErrs,
+				fmt.Errorf("SetUp() failed: %v", err))
+			return allErrs
+		}
+	}
+
+	// gitRepo volume should create its own empty wrapper path
+	podWrapperMetadataDir := fmt.Sprintf("%v/pods/poduid/plugins/kubernetes.io~empty-dir/wrapped_%v", rootDir, scenario.vol.Name)
+
+	if _, err := os.Stat(podWrapperMetadataDir); err != nil {
+		if os.IsNotExist(err) {
+			allErrs = append(allErrs,
+				fmt.Errorf("SetUp() failed, empty-dir wrapper path is not created: %s", podWrapperMetadataDir))
+		} else {
+			allErrs = append(allErrs,
+				fmt.Errorf("SetUp() failed: %v", err))
+		}
+	}
+
+	unmounter, err := plug.NewUnmounter("vol1", types.UID("poduid"))
+	if err != nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("Failed to make a new Unmounter: %v", err))
+		return allErrs
+	}
+	if unmounter == nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("Got a nil Unmounter"))
+		return allErrs
+	}
+
+	if err := unmounter.TearDown(); err != nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("Expected success, got: %v", err))
+		return allErrs
+	}
+	if _, err := os.Stat(path); err == nil {
+		allErrs = append(allErrs,
+			fmt.Errorf("TearDown() failed, volume path still exists: %s", path))
+	} else if !os.IsNotExist(err) {
+		allErrs = append(allErrs,
+			fmt.Errorf("TearDown() failed: %v", err))
+	}
+	return allErrs
+}
+
+func doTestSetUp(scenario struct {
+	name              string
+	vol               *v1.Volume
+	expecteds         []expectedCommand
+	isExpectedFailure bool
+}, mounter volume.Mounter) []error {
+	expecteds := scenario.expecteds
+	allErrs := []error{}
+
+	// Construct combined outputs from expected commands
+	var fakeOutputs []fakeexec.FakeCombinedOutputAction
+	var fcmd fakeexec.FakeCmd
+	for _, expected := range expecteds {
+		if expected.cmd[1] == "clone" {
+			fakeOutputs = append(fakeOutputs, func() ([]byte, error) {
+				// git clone, it creates new dir/files
+				os.MkdirAll(path.Join(fcmd.Dirs[0], expected.dir), 0750)
+				return []byte{}, nil
+			})
+		} else {
+			// git checkout || git reset, they create nothing
+			fakeOutputs = append(fakeOutputs, func() ([]byte, error) {
+				return []byte{}, nil
+			})
+		}
+	}
+	fcmd = fakeexec.FakeCmd{
+		CombinedOutputScript: fakeOutputs,
+	}
+
+	// Construct fake exec outputs from fcmd
+	var fakeAction []fakeexec.FakeCommandAction
+	for i := 0; i < len(expecteds); i++ {
+		fakeAction = append(fakeAction, func(cmd string, args ...string) exec.Cmd {
+			return fakeexec.InitFakeCmd(&fcmd, cmd, args...)
+		})
+
+	}
+	fake := fakeexec.FakeExec{
+		CommandScript: fakeAction,
+	}
+
+	g := mounter.(*gitRepoVolumeMounter)
+	g.exec = &fake
+
+	g.SetUp(nil)
+
+	if fake.CommandCalls != len(expecteds) {
+		allErrs = append(allErrs,
+			fmt.Errorf("unexpected command calls in scenario: expected %d, saw: %d", len(expecteds), fake.CommandCalls))
+	}
+	var expectedCmds [][]string
+	for _, expected := range expecteds {
+		expectedCmds = append(expectedCmds, expected.cmd)
+	}
+	if !reflect.DeepEqual(expectedCmds, fcmd.CombinedOutputLog) {
+		allErrs = append(allErrs,
+			fmt.Errorf("unexpected commands: %v, expected: %v", fcmd.CombinedOutputLog, expectedCmds))
+	}
+
+	var expectedPaths []string
+	for _, expected := range expecteds {
+		expectedPaths = append(expectedPaths, g.GetPath()+expected.dir)
+	}
+	if len(fcmd.Dirs) != len(expectedPaths) || !reflect.DeepEqual(expectedPaths, fcmd.Dirs) {
+		allErrs = append(allErrs,
+			fmt.Errorf("unexpected directories: %v, expected: %v", fcmd.Dirs, expectedPaths))
+	}
+
+	return allErrs
+}