terraform: Diff.String

terraform/diff.go

@@ -1,21 +1,58 @@
 package terraform
 
 import (
+	"bytes"
+	"fmt"
+	"sort"
 	"sync"
 )
 
 // Diff tracks the differences between resources to apply.
 type Diff struct {
-	Resources map[string]map[string]*ResourceAttrDiff
+	Resources map[string]*ResourceDiff
 	once      sync.Once
 }
 
 func (d *Diff) init() {
 	d.once.Do(func() {
-		d.Resources = make(map[string]map[string]*ResourceAttrDiff)
+		if d.Resources == nil {
+			d.Resources = make(map[string]*ResourceDiff)
+		}
 	})
 }
 
+// String outputs the diff in a long but command-line friendly output
+// format that users can read to quickly inspect a diff.
+func (d *Diff) String() string {
+	var buf bytes.Buffer
+
+	names := make([]string, 0, len(d.Resources))
+	for name, _ := range d.Resources {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	for _, name := range names {
+		buf.WriteString(name + "\n")
+
+		rdiff := d.Resources[name]
+		for attrK, attrDiff := range rdiff.Attributes {
+			v := attrDiff.New
+			if attrDiff.NewComputed {
+				v = "<computed>"
+			}
+
+			buf.WriteString(fmt.Sprintf(
+				"  %s: %#v => %#v\n",
+				attrK,
+				attrDiff.Old,
+				v))
+		}
+	}
+
+	return buf.String()
+}
+
 // ResourceDiff is the diff of a resource from some state to another.
 type ResourceDiff struct {
 	Attributes map[string]*ResourceAttrDiff

terraform/diff_test.go

@@ -1,37 +1,37 @@
 package terraform
 
 import (
-	"bytes"
+	"strings"
-	"fmt"
+	"testing"
-	"sort"
 )
 
-func testDiffStr(d *Diff) string {
+func TestDiff_String(t *testing.T) {
-	var buf bytes.Buffer
+	diff := &Diff{
-
+		Resources: map[string]*ResourceDiff{
-	names := make([]string, len(d.Resources))
+			"nodeA": &ResourceDiff{
-	for n, _ := range d.Resources {
+				Attributes: map[string]*ResourceAttrDiff{
-		names = append(names, n)
+					"foo": &ResourceAttrDiff{
-	}
+						Old: "foo",
-	sort.Strings(names)
+						New: "bar",
-
+					},
-	for _, n := range names {
+					"bar": &ResourceAttrDiff{
-		r := d.Resources[n]
+						Old:         "foo",
-		buf.WriteString(fmt.Sprintf("%s\n", n))
+						NewComputed: true,
-		for attr, attrDiff := range r {
+					},
-			v := attrDiff.New
+				},
-			if attrDiff.NewComputed {
+			},
-				v = "<computed>"
+		},
-			}
-
-			buf.WriteString(fmt.Sprintf(
-				"  %s: %#v => %#v\n",
-				attr,
-				attrDiff.Old,
-				v,
-			))
-		}
 	}
 
-	return buf.String()
+	actual := strings.TrimSpace(diff.String())
+	expected := strings.TrimSpace(diffStrBasic)
+	if actual != expected {
+		t.Fatalf("bad:\n%s", actual)
+	}
 }
+
+const diffStrBasic = `
+nodeA
+  foo: "foo" => "bar"
+  bar: "foo" => "<computed>"
+`

terraform/terraform.go

@@ -163,7 +163,7 @@ func (t *Terraform) diffWalkFn(
 		defer l.Unlock()
 
 		// Update the resulting diff
-		result.Resources[r.Id()] = diff.Attributes
+		result.Resources[r.Id()] = diff
 
 		// Determine the new state and update variables
 		rs = rs.MergeDiff(diff.Attributes, ComputedPlaceholder)

terraform/terraform_test.go

@@ -195,7 +195,7 @@ func TestTerraformDiff(t *testing.T) {
 		t.Fatalf("bad: %#v", diff.Resources)
 	}
 
-	actual := strings.TrimSpace(testDiffStr(diff))
+	actual := strings.TrimSpace(diff.String())
 	expected := strings.TrimSpace(testTerraformDiffStr)
 	if actual != expected {
 		t.Fatalf("bad:\n%s", actual)
@@ -226,7 +226,7 @@ func TestTerraformDiff_computed(t *testing.T) {
 		t.Fatalf("bad: %#v", diff.Resources)
 	}
 
-	actual := strings.TrimSpace(testDiffStr(diff))
+	actual := strings.TrimSpace(diff.String())
 	expected := strings.TrimSpace(testTerraformDiffComputedStr)
 	if actual != expected {
 		t.Fatalf("bad:\n%s", actual)