Implement a function for workspace selection, or creation

modules/terraform/workspace.go

@@ -0,0 +1,55 @@
+package terraform
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// WorkspaceSelectOrNew runs terraform workspace with the given options and the workspace name
+// and returns a name of the current workspace. It tries to select a workspace with the given
+// name, or it creates a new one if it doesn't exist.
+func WorkspaceSelectOrNew(t *testing.T, options *Options, name string) string {
+	out, err := WorkspaceSelectOrNewE(t, options, name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return out
+}
+
+// WorkspaceSelectOrNewE runs terraform workspace with the given options and the workspace name
+// and returns a name of the current workspace. It tries to select a workspace with the given
+// name, or it creates a new one if it doesn't exist.
+func WorkspaceSelectOrNewE(t *testing.T, options *Options, name string) (string, error) {
+	out, err := RunTerraformCommandE(t, options, "workspace", "list")
+	if err != nil {
+		return "", err
+	}
+
+	if isExistingWorkspace(out, name) {
+		_, err = RunTerraformCommandE(t, options, "workspace", "select", name)
+	} else {
+		_, err = RunTerraformCommandE(t, options, "workspace", "new", name)
+	}
+	if err != nil {
+		return "", err
+	}
+
+	return RunTerraformCommandE(t, options, "workspace", "show")
+}
+
+func isExistingWorkspace(out string, name string) bool {
+	workspaces := strings.Split(out, "\n")
+	for _, ws := range workspaces {
+		if nameMatchesWorkspace(name, ws) {
+			return true
+		}
+	}
+	return false
+}
+
+func nameMatchesWorkspace(name string, workspace string) bool {
+	match, _ := regexp.MatchString(fmt.Sprintf("^\\*?\\s*%s$", name), workspace)
+	return match
+}

modules/terraform/workspace_test.go

@@ -0,0 +1,132 @@
+package terraform
+
+import (
+	"testing"
+
+	"github.com/gruntwork-io/terratest/modules/files"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWorkspaceNew(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerraformFolderToTemp("../../test/fixtures/terraform-workspace", t.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	options := &Options{
+		TerraformDir: testFolder,
+	}
+
+	out := WorkspaceSelectOrNew(t, options, "terratest")
+
+	assert.Equal(t, "terratest", out)
+}
+
+func TestWorkspaceIllegalName(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerraformFolderToTemp("../../test/fixtures/terraform-workspace", t.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	options := &Options{
+		TerraformDir: testFolder,
+	}
+
+	out, err := WorkspaceSelectOrNewE(t, options, "###@@@&&&")
+
+	assert.Error(t, err)
+	assert.Equal(t, "", out, "%q should be an empty string", out)
+}
+
+func TestWorkspaceSelect(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerraformFolderToTemp("../../test/fixtures/terraform-workspace", t.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	options := &Options{
+		TerraformDir: testFolder,
+	}
+
+	out := WorkspaceSelectOrNew(t, options, "terratest")
+	assert.Equal(t, "terratest", out)
+
+	out = WorkspaceSelectOrNew(t, options, "default")
+	assert.Equal(t, "default", out)
+}
+
+func TestWorkspaceApply(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerraformFolderToTemp("../../test/fixtures/terraform-workspace", t.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	options := &Options{
+		TerraformDir: testFolder,
+	}
+
+	WorkspaceSelectOrNew(t, options, "Terratest")
+	out := InitAndApply(t, options)
+
+	assert.Contains(t, out, "Hello, Terratest")
+}
+
+func TestIsExistingWorkspace(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		out      string
+		name     string
+		expected bool
+	}{
+		{"  default\n* foo\n", "default", true},
+		{"* default\n  foo\n", "default", true},
+		{"  foo\n* default\n", "default", true},
+		{"* foo\n  default\n", "default", true},
+		{"  foo\n* bar\n", "default", false},
+		{"* foo\n  bar\n", "default", false},
+		{"  default\n* foobar\n", "foo", false},
+		{"* default\n  foobar\n", "foo", false},
+		{"  default\n* foo\n", "foobar", false},
+		{"* default\n  foo\n", "foobar", false},
+		{"* default\n  foo\n", "foo", true},
+	}
+
+	for _, testCase := range testCases {
+		actual := isExistingWorkspace(testCase.out, testCase.name)
+		assert.Equal(t, testCase.expected, actual, "Out: %q, Name: %q", testCase.out, testCase.name)
+	}
+}
+
+func TestNameMatchesWorkspace(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name      string
+		workspace string
+		expected  bool
+	}{
+		{"default", "  default", true},
+		{"default", "* default", true},
+		{"default", "", false},
+		{"foo", "  foobar", false},
+		{"foo", "* foobar", false},
+		{"foobar", "  foo", false},
+		{"foobar", "* foo", false},
+		{"foo", "  foo", true},
+		{"foo", "* foo", true},
+	}
+
+	for _, testCase := range testCases {
+		actual := nameMatchesWorkspace(testCase.name, testCase.workspace)
+		assert.Equal(t, testCase.expected, actual, "Name: %q, Workspace: %q", testCase.name, testCase.workspace)
+	}
+}

test/fixtures/terraform-workspace/main.tf

@@ -0,0 +1,3 @@
+output "test" {
+  value = "Hello, ${terraform.workspace}"
+}