Implement comparison state checks to replace TestCheckResourceAttrPtr, TestCheckResourceAttrPair and TestCheckTypeSetElemAttrPair

compare/doc.go

@@ -0,0 +1,5 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+// Package compare contains the value comparer interface, and types implementing the value comparer interface.
+package compare

compare/value_comparer.go

@@ -0,0 +1,13 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare
+
+// ValueComparer defines an interface that is implemented to run comparison logic on multiple values. Individual
+// implementations determine how the comparison is performed (e.g., values differ, values equal).
+type ValueComparer interface {
+	// CompareValues should assert the given known values against any expectations.
+	// Values are always ordered in the order they were added. Use the error
+	// return to signal unexpected values or implementation errors.
+	CompareValues(values ...any) error
+}

compare/values_differ.go

@@ -0,0 +1,31 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var _ ValueComparer = valuesDiffer{}
+
+type valuesDiffer struct{}
+
+// CompareValues determines whether each value in the sequence of the supplied values
+// differs from the preceding value.
+func (v valuesDiffer) CompareValues(values ...any) error {
+	for i := 1; i < len(values); i++ {
+		if reflect.DeepEqual(values[i-1], values[i]) {
+			return fmt.Errorf("expected values to differ, but they are the same: %v == %v", values[i-1], values[i])
+		}
+	}
+
+	return nil
+}
+
+// ValuesDiffer returns a ValueComparer for asserting that each value in the sequence of
+// the values supplied to the CompareValues method differs from the preceding value.
+func ValuesDiffer() valuesDiffer {
+	return valuesDiffer{}
+}

compare/values_differ_all.go

@@ -0,0 +1,33 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var _ ValueComparer = valuesDifferAll{}
+
+type valuesDifferAll struct{}
+
+// CompareValues determines whether each value in the supplied values
+// is unique.
+func (v valuesDifferAll) CompareValues(values ...any) error {
+	for i := 0; i < len(values); i++ {
+		for j := i + 1; j < len(values); j++ {
+			if reflect.DeepEqual(values[i], values[j]) {
+				return fmt.Errorf("expected values to differ, but value is duplicated: %v", values[i])
+			}
+		}
+	}
+
+	return nil
+}
+
+// ValuesDifferAll returns a ValueComparer for asserting that each value in the
+// values supplied to the CompareValues method is unique.
+func ValuesDifferAll() valuesDifferAll {
+	return valuesDifferAll{}
+}

compare/values_differ_all_test.go

@@ -0,0 +1,66 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/hashicorp/terraform-plugin-testing/compare"
+)
+
+func TestValuesDifferAll_CompareValues(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		in            []any
+		expectedError error
+	}{
+		"nil": {},
+		"single-value": {
+			in: []any{"str"},
+		},
+		"non-matching-values": {
+			in: []any{"str", "other_str", "another_str"},
+		},
+		"matching-values-string": {
+			in:            []any{"str", "str"},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: str"),
+		},
+		"non-sequential-matching-values-string": {
+			in:            []any{"str", "other_str", "str"},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: str"),
+		},
+		"matching-values-slice": {
+			in: []any{
+				[]any{"str"},
+				[]any{"str"},
+			},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: [str]"),
+		},
+		"matching-values-map": {
+			in: []any{
+				map[string]any{"a": "str"},
+				map[string]any{"a": "str"},
+			},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: map[a:str]"),
+		},
+	}
+
+	for name, testCase := range testCases {
+		name, testCase := name, testCase
+
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			err := compare.ValuesDifferAll().CompareValues(testCase.in...)
+
+			if diff := cmp.Diff(err, testCase.expectedError, equateErrorMessage); diff != "" {
+				t.Errorf("unexpected difference: %s", diff)
+			}
+		})
+	}
+}

compare/values_differ_any.go

@@ -0,0 +1,40 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var _ ValueComparer = valuesDifferAny{}
+
+type valuesDifferAny struct{}
+
+// CompareValues determines whether any value in the supplied values
+// is unique.
+func (v valuesDifferAny) CompareValues(values ...any) error {
+	if len(values) < 2 {
+		return nil
+	}
+
+	var val any
+
+	for i := 0; i < len(values); i++ {
+		val = values[i]
+		for j := 1; j < len(values); j++ {
+			if !reflect.DeepEqual(values[i], values[j]) {
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("expected values to differ, but value is duplicated: %v", val)
+}
+
+// ValuesDifferAny returns a ValueComparer for asserting that any value in the
+// values supplied to the CompareValues method is unique.
+func ValuesDifferAny() valuesDifferAny {
+	return valuesDifferAny{}
+}

compare/values_differ_any_test.go

@@ -0,0 +1,69 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/hashicorp/terraform-plugin-testing/compare"
+)
+
+func TestValuesDifferAny_CompareValues(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		in            []any
+		expectedError error
+	}{
+		"nil": {},
+		"single-value": {
+			in: []any{"str"},
+		},
+		"non-matching-sequential-values-string": {
+			in: []any{"str", "other_str", "str"},
+		},
+		"non-matching-sequential-values-slice": {
+			in: []any{
+				[]any{"str"},
+				[]any{"other_str"},
+				[]any{"str"},
+			},
+		},
+		"matching-values-string": {
+			in:            []any{"str", "str"},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: str"),
+		},
+		"matching-values-slice": {
+			in: []any{
+				[]any{"str"},
+				[]any{"str"},
+			},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: [str]"),
+		},
+		"matching-values-map": {
+			in: []any{
+				map[string]any{"a": "str"},
+				map[string]any{"a": "str"},
+			},
+			expectedError: fmt.Errorf("expected values to differ, but value is duplicated: map[a:str]"),
+		},
+	}
+
+	for name, testCase := range testCases {
+		name, testCase := name, testCase
+
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			err := compare.ValuesDifferAny().CompareValues(testCase.in...)
+
+			if diff := cmp.Diff(err, testCase.expectedError, equateErrorMessage); diff != "" {
+				t.Errorf("unexpected difference: %s", diff)
+			}
+		})
+	}
+}

compare/values_differ_test.go

@@ -0,0 +1,62 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/hashicorp/terraform-plugin-testing/compare"
+)
+
+func TestValuesDiffer_CompareValues(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		in            []any
+		expectedError error
+	}{
+		"nil": {},
+		"single-value": {
+			in: []any{"str"},
+		},
+		"non-matching-sequential-values": {
+			in: []any{"str", "other_str", "str"},
+		},
+		"matching-values-string": {
+			in:            []any{"str", "other_str", "other_str"},
+			expectedError: fmt.Errorf("expected values to differ, but they are the same: other_str == other_str"),
+		},
+		"matching-values-slice": {
+			in: []any{
+				[]any{"other_str"},
+				[]any{"other_str"},
+			},
+			expectedError: fmt.Errorf("expected values to differ, but they are the same: [other_str] == [other_str]"),
+		},
+		"matching-values-map": {
+			in: []any{
+				map[string]any{"a": "other_str"},
+				map[string]any{"a": "other_str"},
+			},
+			expectedError: fmt.Errorf("expected values to differ, but they are the same: map[a:other_str] == map[a:other_str]"),
+		},
+	}
+
+	for name, testCase := range testCases {
+		name, testCase := name, testCase
+
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			err := compare.ValuesDiffer().CompareValues(testCase.in...)
+
+			if diff := cmp.Diff(err, testCase.expectedError, equateErrorMessage); diff != "" {
+				t.Errorf("unexpected difference: %s", diff)
+			}
+		})
+	}
+}

compare/values_same.go

@@ -0,0 +1,31 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var _ ValueComparer = valuesSame{}
+
+type valuesSame struct{}
+
+// CompareValues determines whether each value in the sequence of the supplied values
+// is the same as the preceding value.
+func (v valuesSame) CompareValues(values ...any) error {
+	for i := 1; i < len(values); i++ {
+		if !reflect.DeepEqual(values[i-1], values[i]) {
+			return fmt.Errorf("expected values to be the same, but they differ: %v != %v", values[i-1], values[i])
+		}
+	}
+
+	return nil
+}
+
+// ValuesSame returns a ValueComparer for asserting that each value in the sequence of
+// the values supplied to the CompareValues method is the same as the preceding value.
+func ValuesSame() valuesSame {
+	return valuesSame{}
+}

compare/values_same_any.go

@@ -0,0 +1,37 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compare
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var _ ValueComparer = valuesSameAny{}
+
+type valuesSameAny struct{}
+
+// CompareValues determines whether any value in the supplied values
+// matches any other value.
+func (v valuesSameAny) CompareValues(values ...any) error {
+	if len(values) < 2 {
+		return nil
+	}
+
+	for i := 0; i < len(values); i++ {
+		for j := i + 1; j < len(values); j++ {
+			if reflect.DeepEqual(values[i], values[j]) {
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("expected at least two values to be the same, but all values differ")
+}
+
+// ValuesSameAny returns a ValueComparer for asserting whether any value in the
+// values supplied to the CompareValues method is the same as any other value.
+func ValuesSameAny() valuesSameAny {
+	return valuesSameAny{}
+}