knownvalue: Add Int32Exact and Float32Exact checks (#356)

* Add `float32exact` and `int32exact` types

* Update website documentation

* Add changelog entries

* Update changelog wording

.changes/unreleased/ENHANCEMENTS-20240626-163240.yaml

@@ -0,0 +1,5 @@
+kind: ENHANCEMENTS
+body: 'knownvalue: Add `Int32Exact` check for int32 value testing.'
+time: 2024-06-26T16:32:40.387821-04:00
+custom:
+ Issue: "356"

.changes/unreleased/ENHANCEMENTS-20240626-163311.yaml

@@ -0,0 +1,5 @@
+kind: ENHANCEMENTS
+body: 'knownvalue: Add `Float32Exact` check for float32 value testing.'
+time: 2024-06-26T16:33:11.495969-04:00
+custom:
+ Issue: "356"

knownvalue/float32.go

@@ -0,0 +1,51 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package knownvalue
+
+import (
+ "encoding/json"
+ "fmt"
+ "strconv"
+)
+
+var _ Check = float32Exact{}
+
+type float32Exact struct {
+ value float32
+}
+
+// CheckValue determines whether the passed value is of type float32, and
+// contains a matching float32 value.
+func (v float32Exact) CheckValue(other any) error {
+ jsonNum, ok := other.(json.Number)
+
+ if !ok {
+ return fmt.Errorf("expected json.Number value for Float32Exact check, got: %T", other)
+ }
+
+ otherVal, err := strconv.ParseFloat(string(jsonNum), 32)
+
+ if err != nil {
+ return fmt.Errorf("expected json.Number to be parseable as float32 value for Float32Exact check: %s", err)
+ }
+
+ if float32(otherVal) != v.value {
+ return fmt.Errorf("expected value %s for Float32Exact check, got: %s", v.String(), strconv.FormatFloat(otherVal, 'f', -1, 32))
+ }
+
+ return nil
+}
+
+// String returns the string representation of the float32 value.
+func (v float32Exact) String() string {
+ return strconv.FormatFloat(float64(v.value), 'f', -1, 32)
+}
+
+// Float32Exact returns a Check for asserting equality between the
+// supplied float32 and the value passed to the CheckValue method.
+func Float32Exact(value float32) float32Exact {
+ return float32Exact{
+ value: value,
+ }
+}

knownvalue/float32_test.go

@@ -0,0 +1,75 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package knownvalue_test
+
+import (
+ "encoding/json"
+ "fmt"
+ "testing"
+
+ "github.com/google/go-cmp/cmp"
+
+ "github.com/hashicorp/terraform-plugin-testing/knownvalue"
+)
+
+func TestFloat32Value_CheckValue(t *testing.T) {
+ t.Parallel()
+
+ testCases := map[string]struct {
+ self knownvalue.Check
+ other any
+ expectedError error
+ }{
+ "zero-nil": {
+ self: knownvalue.Float32Exact(0),
+ expectedError: fmt.Errorf("expected json.Number value for Float32Exact check, got: <nil>"),
+ },
+ "zero-other": {
+ self: knownvalue.Float32Exact(0),
+ other: json.Number("0.0"), // checking against the underlying value field zero-value
+ },
+ "nil": {
+ self: knownvalue.Float32Exact(1.234),
+ expectedError: fmt.Errorf("expected json.Number value for Float32Exact check, got: <nil>"),
+ },
+ "wrong-type": {
+ self: knownvalue.Float32Exact(1.234),
+ other: json.Number("str"),
+ expectedError: fmt.Errorf("expected json.Number to be parseable as float32 value for Float32Exact check: strconv.ParseFloat: parsing \"str\": invalid syntax"),
+ },
+ "not-equal": {
+ self: knownvalue.Float32Exact(1.234),
+ other: json.Number("4.321"),
+ expectedError: fmt.Errorf("expected value 1.234 for Float32Exact check, got: 4.321"),
+ },
+ "equal": {
+ self: knownvalue.Float32Exact(1.234),
+ other: json.Number("1.234"),
+ },
+ }
+
+ for name, testCase := range testCases {
+ name, testCase := name, testCase
+
+ t.Run(name, func(t *testing.T) {
+ t.Parallel()
+
+ got := testCase.self.CheckValue(testCase.other)
+
+ if diff := cmp.Diff(got, testCase.expectedError, equateErrorMessage); diff != "" {
+ t.Errorf("unexpected difference: %s", diff)
+ }
+ })
+ }
+}
+
+func TestFloat32Value_String(t *testing.T) {
+ t.Parallel()
+
+ got := knownvalue.Float32Exact(1.234567890123e+03).String()
+
+ if diff := cmp.Diff(got, "1234.5679"); diff != "" {
+ t.Errorf("unexpected difference: %s", diff)
+ }
+}

knownvalue/int32.go

@@ -0,0 +1,51 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package knownvalue
+
+import (
+ "encoding/json"
+ "fmt"
+ "strconv"
+)
+
+var _ Check = int32Exact{}
+
+type int32Exact struct {
+ value int32
+}
+
+// CheckValue determines whether the passed value is of type int32, and
+// contains a matching int32 value.
+func (v int32Exact) CheckValue(other any) error {
+ jsonNum, ok := other.(json.Number)
+
+ if !ok {
+ return fmt.Errorf("expected json.Number value for Int32Exact check, got: %T", other)
+ }
+
+ otherVal, err := strconv.ParseInt(string(jsonNum), 10, 32)
+
+ if err != nil {
+ return fmt.Errorf("expected json.Number to be parseable as int32 value for Int32Exact check: %s", err)
+ }
+
+ if int32(otherVal) != v.value {
+ return fmt.Errorf("expected value %d for Int32Exact check, got: %d", v.value, otherVal)
+ }
+
+ return nil
+}
+
+// String returns the string representation of the int32 value.
+func (v int32Exact) String() string {
+ return strconv.FormatInt(int64(v.value), 10)
+}
+
+// Int32Exact returns a Check for asserting equality between the
+// supplied int32 and the value passed to the CheckValue method.
+func Int32Exact(value int32) int32Exact {
+ return int32Exact{
+ value: value,
+ }
+}

knownvalue/int32_test.go

@@ -0,0 +1,75 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package knownvalue_test
+
+import (
+ "encoding/json"
+ "fmt"
+ "testing"
+
+ "github.com/google/go-cmp/cmp"
+
+ "github.com/hashicorp/terraform-plugin-testing/knownvalue"
+)
+
+func TestInt32Value_CheckValue(t *testing.T) {
+ t.Parallel()
+
+ testCases := map[string]struct {
+ self knownvalue.Check
+ other any
+ expectedError error
+ }{
+ "zero-nil": {
+ self: knownvalue.Int32Exact(0),
+ expectedError: fmt.Errorf("expected json.Number value for Int32Exact check, got: <nil>"),
+ },
+ "zero-other": {
+ self: knownvalue.Int32Exact(0),
+ other: json.Number("0"), // checking against the underlying value field zero-value
+ },
+ "nil": {
+ self: knownvalue.Int32Exact(1234),
+ expectedError: fmt.Errorf("expected json.Number value for Int32Exact check, got: <nil>"),
+ },
+ "wrong-type": {
+ self: knownvalue.Int32Exact(1234),
+ other: json.Number("str"),
+ expectedError: fmt.Errorf("expected json.Number to be parseable as int32 value for Int32Exact check: strconv.ParseInt: parsing \"str\": invalid syntax"),
+ },
+ "not-equal": {
+ self: knownvalue.Int32Exact(1234),
+ other: json.Number("4321"),
+ expectedError: fmt.Errorf("expected value 1234 for Int32Exact check, got: 4321"),
+ },
+ "equal": {
+ self: knownvalue.Int32Exact(1234),
+ other: json.Number("1234"),
+ },
+ }
+
+ for name, testCase := range testCases {
+ name, testCase := name, testCase
+
+ t.Run(name, func(t *testing.T) {
+ t.Parallel()
+
+ got := testCase.self.CheckValue(testCase.other)
+
+ if diff := cmp.Diff(got, testCase.expectedError, equateErrorMessage); diff != "" {
+ t.Errorf("unexpected difference: %s", diff)
+ }
+ })
+ }
+}
+
+func TestInt32Value_String(t *testing.T) {
+ t.Parallel()
+
+ got := knownvalue.Int32Exact(123456789).String()
+
+ if diff := cmp.Diff(got, "123456789"); diff != "" {
+ t.Errorf("unexpected difference: %s", diff)
+ }
+}

website/data/plugin-testing-nav-data.json

@@ -86,10 +86,18 @@
  "title": "Custom",
  "path": "acceptance-tests/known-value-checks/custom"
  },
+ {
+ "title": "Float32",
+ "path": "acceptance-tests/known-value-checks/float32"
+ },
  {
  "title": "Float64",
  "path": "acceptance-tests/known-value-checks/float64"
  },
+ {
+ "title": "Int32",
+ "path": "acceptance-tests/known-value-checks/int32"
+ },
  {
  "title": "Int64",
  "path": "acceptance-tests/known-value-checks/int64"

website/docs/plugin/testing/acceptance-tests/known-value-checks/custom.mdx

@@ -63,7 +63,9 @@ The `other` parameter passed to the `CheckValue` method is one of the following
 Refer to the following built-in known value checks for implementations that handle the different types that can be passed to the `CheckValue` method in the `other` parameter:
 
 * [Bool](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Bool)
+* [Float32Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Float32Exact)
 * [Float64Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Float64Exact)
+* [Int32Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Int32Exact)
 * [Int64Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Int64Exact)
 * [ListExact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#ListExact)
 * [MapExact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#MapExact)

website/docs/plugin/testing/acceptance-tests/known-value-checks/float32.mdx

@@ -0,0 +1,42 @@
+---
+page_title: 'Plugin Development - Acceptance Testing: Known Values'
+description: >-
+ Float32 Value Checks for use with Plan Checks.
+---
+
+# Float32 Known Value Checks
+
+The known value checks that are available for float32 values are:
+
+* [Float32Exact](/terraform/plugin/testing/acceptance-tests/known-value-checks/float32#float32exact-check)
+
+## `Float32Exact` Check
+
+The [Float32Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Float32Exact) check tests that a resource attribute, or output value has an exactly matching float32 value.
+
+Example usage of [Float32Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Float32Exact) in an [ExpectKnownValue](/terraform/plugin/testing/acceptance-tests/plan-checks/resource) plan check.
+
+```go
+func TestExpectKnownValue_CheckPlan_Float32(t *testing.T) {
+ t.Parallel()
+
+ resource.Test(t, resource.TestCase{
+ // Provider definition omitted.
+ Steps: []resource.TestStep{
+ {
+ // Example resource containing a computed float32 attribute named "computed_attribute"
+ Config: `resource "test_resource" "one" {}`,
+ ConfigPlanChecks: resource.ConfigPlanChecks{
+ PreApply: []plancheck.PlanCheck{
+ plancheck.ExpectKnownValue(
+ "test_resource.one",
+ tfjsonpath.New("computed_attribute"),
+ knownvalue.Float32Exact(1.23),
+ ),
+ },
+ },
+ },
+ },
+ })
+}
+```

website/docs/plugin/testing/acceptance-tests/known-value-checks/index.mdx

@@ -39,7 +39,9 @@ The following table shows the correspondence between [knownvalue.Check](https://
 | Known Value Check Type | Framework Attribute Type | SDKv2 Attribute Type |
 |------------------------------------------------------------------------------------------------------|---------------------------|----------------------|
 | [Bool Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/bool) | `schema.BoolAttribute` | `schema.TypeBool` |
+| [Float32 Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/float32) | `schema.Float32Attribute` | `schema.TypeFloat` |
 | [Float64 Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/float64) | `schema.Float64Attribute` | `schema.TypeFloat` |
+| [Int32 Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/int32) | `schema.Int32Attribute` | `schema.TypeInt` |
 | [Int64 Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/int64) | `schema.Int64Attribute` | `schema.TypeInt` |
 | [List Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/list) | `schema.ListAttribute` | `schema.TypeList` |
 | [Map Known Value Checks](/terraform/plugin/testing/acceptance-tests/known-value-checks/map) | `schema.MapAttribute` | `schema.TypeMap` |

website/docs/plugin/testing/acceptance-tests/known-value-checks/int32.mdx

@@ -0,0 +1,42 @@
+---
+page_title: 'Plugin Development - Acceptance Testing: Known Values'
+description: >-
+ Int32 Value Checks for use with Plan Checks.
+---
+
+# Int32 Known Value Checks
+
+The known value checks that are available for int32 values are:
+
+* [Int32Exact](/terraform/plugin/testing/acceptance-tests/known-value-checks/int32#int32exact-check)
+
+## `Int32Exact` Check
+
+The [Int32Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Int32Exact) check tests that a resource attribute, or output value has an exactly matching int32 value.
+
+Example usage of [Int32Exact](https://pkg.go.dev/github.com/hashicorp/terraform-plugin-testing/knownvalue#Int32Exact) in an [ExpectKnownValue](/terraform/plugin/testing/acceptance-tests/plan-checks/resource) plan check.
+
+```go
+func TestExpectKnownValue_CheckPlan_Int32(t *testing.T) {
+ t.Parallel()
+
+ resource.Test(t, resource.TestCase{
+ // Provider definition omitted.
+ Steps: []resource.TestStep{
+ {
+ // Example resource containing a computed int32 attribute named "computed_attribute"
+ Config: `resource "test_resource" "one" {}`,
+ ConfigPlanChecks: resource.ConfigPlanChecks{
+ PreApply: []plancheck.PlanCheck{
+ plancheck.ExpectKnownValue(
+ "test_resource.one",
+ tfjsonpath.New("computed_attribute"),
+ knownvalue.Int32Exact(123),
+ ),
+ },
+ },
+ },
+ },
+ })
+}
+```