Improve provisiontest.FakeSSHCommander

Signed-off-by: Rob Van Mieghem <rob@vanmieghemcloud.com>

libmachine/provision/arch_test.go

@@ -12,7 +12,7 @@ import (
 
 func TestArchDefaultStorageDriver(t *testing.T) {
 	p := NewArchProvisioner(&fakedriver.Driver{}).(*ArchProvisioner)
-	p.SSHCommander = provisiontest.FakeSSHCommander{FilesystemType: "ext4"}
+	p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{})
 	p.Provision(swarm.Options{}, auth.Options{}, engine.Options{})
 	if p.EngineOptions.StorageDriver != "overlay" {
 		t.Fatal("Default storage driver should be overlay")

libmachine/provision/debian_test.go

@@ -12,7 +12,7 @@ import (
 
 func TestDebianDefaultStorageDriver(t *testing.T) {
 	p := NewDebianProvisioner(&fakedriver.Driver{}).(*DebianProvisioner)
-	p.SSHCommander = provisiontest.FakeSSHCommander{FilesystemType: "ext4"}
+	p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{})
 	p.Provision(swarm.Options{}, auth.Options{}, engine.Options{})
 	if p.EngineOptions.StorageDriver != "aufs" {
 		t.Fatal("Default storage driver should be aufs")

libmachine/provision/provisiontest/sshcommander.go

@@ -1,22 +1,39 @@
 //Package provisiontest provides utilities for testing provisioners
 package provisiontest
 
-import (
-	"errors"
-	"strings"
-)
+import "errors"
 
-//FakeSSHCommander is an implementation of provision.SSHCommander to provide predictable responses set by testing code
-//Extend it when needed
-type FakeSSHCommander struct {
+//FakeSSHCommanderOptions is intended to create a FakeSSHCommander without actually knowing the underlying sshcommands by passing it to NewSSHCommander
+type FakeSSHCommanderOptions struct {
 	//Result of the ssh command to look up the FilesystemType
 	FilesystemType string
 }
 
-//SSHCommand is an implementation of provision.SSHCommander.SSHCommand to provide predictable responses set by testing code
-func (sshCmder FakeSSHCommander) SSHCommand(args string) (string, error) {
-	if !strings.HasPrefix(args, "stat -f") {
-		return "", errors.New("Not implemented by FakeSSHCommander")
-	}
-	return sshCmder.FilesystemType + "\n", nil
+//FakeSSHCommander is an implementation of provision.SSHCommander to provide predictable responses set by testing code
+//Extend it when needed
+type FakeSSHCommander struct {
+	Responses map[string]string
+}
+
+//NewFakeSSHCommander creates a FakeSSHCommander without actually knowing the underlying sshcommands
+func NewFakeSSHCommander(options FakeSSHCommanderOptions) *FakeSSHCommander {
+	if options.FilesystemType == "" {
+		options.FilesystemType = "ext4"
+	}
+	sshCmder := &FakeSSHCommander{
+		Responses: map[string]string{
+			"stat -f -c %T /var/lib": options.FilesystemType + "\n",
+		},
+	}
+
+	return sshCmder
+}
+
+//SSHCommand is an implementation of provision.SSHCommander.SSHCommand to provide predictable responses set by testing code
+func (sshCmder *FakeSSHCommander) SSHCommand(args string) (string, error) {
+	response, commandRegistered := sshCmder.Responses[args]
+	if !commandRegistered {
+		return "", errors.New("Command not registered in FakeSSHCommander")
+	}
+	return response, nil
 }

libmachine/provision/provisiontest/sshcommander_test.go

@@ -1,11 +1,28 @@
 package provisiontest
 
-import "testing"
+import (
+	"testing"
 
-func TestStatSSHCommand(t *testing.T) {
-	sshCmder := FakeSSHCommander{FilesystemType: "btrfs"}
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateFakeSSHCommander(t *testing.T) {
+	sshCmder := NewFakeSSHCommander(FakeSSHCommanderOptions{FilesystemType: "btrfs"})
 	output, err := sshCmder.SSHCommand("stat -f -c %T /var/lib")
 	if err != nil || output != "btrfs\n" {
 		t.Fatal("FakeSSHCommander should have returned btrfs and no error but returned '", output, "' and error", err)
 	}
 }
+
+func TestStatSSHCommand(t *testing.T) {
+	sshCmder := FakeSSHCommander{
+		Responses: map[string]string{"sshcommand": "sshcommandresponse"},
+	}
+
+	output, err := sshCmder.SSHCommand("sshcommand")
+	assert.NoError(t, err)
+	assert.Equal(t, "sshcommandresponse", output)
+
+	output, err = sshCmder.SSHCommand("errorcommand")
+	assert.Error(t, err)
+}

libmachine/provision/redhat_test.go

@@ -35,7 +35,7 @@ func TestRedHatGenerateYumRepoList(t *testing.T) {
 
 func TestRedHatDefaultStorageDriver(t *testing.T) {
 	p := NewRedHatProvisioner("", &fakedriver.Driver{})
-	p.SSHCommander = provisiontest.FakeSSHCommander{FilesystemType: "ext4"}
+	p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{})
 	p.Provision(swarm.Options{}, auth.Options{}, engine.Options{})
 	if p.EngineOptions.StorageDriver != "devicemapper" {
 		t.Fatal("Default storage driver should be devicemapper")

libmachine/provision/ubuntu_systemd_test.go

@@ -36,7 +36,7 @@ func TestUbuntuSystemdCompatibleWithHost(t *testing.T) {
 
 func TestUbuntuSystemdDefaultStorageDriver(t *testing.T) {
 	p := NewUbuntuSystemdProvisioner(&fakedriver.Driver{}).(*UbuntuSystemdProvisioner)
-	p.SSHCommander = provisiontest.FakeSSHCommander{FilesystemType: "ext4"}
+	p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{})
 	p.Provision(swarm.Options{}, auth.Options{}, engine.Options{})
 	if p.EngineOptions.StorageDriver != "aufs" {
 		t.Fatal("Default storage driver should be aufs")

libmachine/provision/ubuntu_upstart_test.go

@@ -36,7 +36,7 @@ func TestUbuntuCompatibleWithHost(t *testing.T) {
 
 func TestUbuntuDefaultStorageDriver(t *testing.T) {
 	p := NewUbuntuProvisioner(&fakedriver.Driver{}).(*UbuntuProvisioner)
-	p.SSHCommander = provisiontest.FakeSSHCommander{FilesystemType: "ext4"}
+	p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{})
 	p.Provision(swarm.Options{}, auth.Options{}, engine.Options{})
 	if p.EngineOptions.StorageDriver != "aufs" {
 		t.Fatal("Default storage driver should be aufs")

libmachine/provision/utils_test.go

@@ -200,13 +200,28 @@ func TestDecideStorageDriver(t *testing.T) {
 	p := &fakeProvisioner{GenericProvisioner{
 		Driver: &fakedriver.Driver{},
 	}}
-	engineOptions := engine.Options{}
 	for _, test := range tests {
-		engineOptions.StorageDriver = test.suppliedDriver
-		p.SSHCommander = provisiontest.FakeSSHCommander{FilesystemType: test.remoteFilesystemType}
+		p.SSHCommander = provisiontest.NewFakeSSHCommander(
+			provisiontest.FakeSSHCommanderOptions{
+				FilesystemType: test.remoteFilesystemType,
+			},
+		)
 		storageDriver, err := decideStorageDriver(p, test.defaultDriver, test.suppliedDriver)
 		assert.NoError(t, err)
 		assert.Equal(t, test.expectedDriver, storageDriver)
 	}
-
+}
+
+func TestGetFilesystemType(t *testing.T) {
+	p := &fakeProvisioner{GenericProvisioner{
+		Driver: &fakedriver.Driver{},
+	}}
+	p.SSHCommander = &provisiontest.FakeSSHCommander{
+		Responses: map[string]string{
+			"stat -f -c %T /var/lib": "btrfs\n",
+		},
+	}
+	fsType, err := getFilesystemType(p, "/var/lib")
+	assert.NoError(t, err)
+	assert.Equal(t, "btrfs", fsType)
 }