Add test cases for assertbson.EqualValue

Author: matthewdale

internal/assert/assertbson/assertbson_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
 )
 
 func TestEqualDocument(t *testing.T) {
@@ -60,3 +61,189 @@ func TestEqualDocument(t *testing.T) {
 		})
 	}
 }
+
+func TestEqualValue(t *testing.T) {
+	t.Parallel()
+
+	t.Run("bson.RawValue", func(t *testing.T) {
+		t.Parallel()
+
+		testCases := []struct {
+			name     string
+			expected bson.RawValue
+			actual   bson.RawValue
+			want     bool
+		}{
+			{
+				name: "equal",
+				expected: bson.RawValue{
+					Type:  bson.TypeInt32,
+					Value: []byte{1, 0, 0, 0},
+				},
+				actual: bson.RawValue{
+					Type:  bson.TypeInt32,
+					Value: []byte{1, 0, 0, 0},
+				},
+				want: true,
+			},
+			{
+				name: "same type, different value",
+				expected: bson.RawValue{
+					Type:  bson.TypeInt32,
+					Value: []byte{1, 0, 0, 0},
+				},
+				actual: bson.RawValue{
+					Type:  bson.TypeInt32,
+					Value: []byte{1, 1, 1, 1},
+				},
+				want: false,
+			},
+			{
+				name: "same value, different type",
+				expected: bson.RawValue{
+					Type:  bson.TypeDouble,
+					Value: []byte{1, 0, 0, 0, 0, 0, 0, 0},
+				},
+				actual: bson.RawValue{
+					Type:  bson.TypeInt64,
+					Value: []byte{1, 0, 0, 0, 0, 0, 0, 0},
+				},
+				want: false,
+			},
+			{
+				name: "different value, different type",
+				expected: bson.RawValue{
+					Type:  bson.TypeInt32,
+					Value: []byte{1, 0, 0, 0},
+				},
+				actual: bson.RawValue{
+					Type:  bson.TypeString,
+					Value: []byte{1, 1, 1, 1},
+				},
+				want: false,
+			},
+			{
+				name: "invalid",
+				expected: bson.RawValue{
+					Type:  bson.TypeInt64,
+					Value: []byte{1, 0, 0, 0},
+				},
+				actual: bson.RawValue{
+					Type:  bson.TypeInt32,
+					Value: []byte{1, 0, 0, 0},
+				},
+				want: false,
+			},
+			{
+				name:     "empty",
+				expected: bson.RawValue{},
+				actual:   bson.RawValue{},
+				want:     true,
+			},
+		}
+
+		for _, tc := range testCases {
+			tc := tc // Capture range variable.
+
+			t.Run(tc.name, func(t *testing.T) {
+				t.Parallel()
+
+				got := EqualValue(new(testing.T), tc.expected, tc.actual)
+				if got != tc.want {
+					t.Errorf("EqualValue(%#v, %#v) = %v, want %v", tc.expected, tc.actual, got, tc.want)
+				}
+			})
+		}
+	})
+
+	t.Run("bsoncore.Value", func(t *testing.T) {
+		t.Parallel()
+
+		testCases := []struct {
+			name     string
+			expected bsoncore.Value
+			actual   bsoncore.Value
+			want     bool
+		}{
+			{
+				name: "equal",
+				expected: bsoncore.Value{
+					Type: bsoncore.TypeInt32,
+					Data: []byte{1, 0, 0, 0},
+				},
+				actual: bsoncore.Value{
+					Type: bsoncore.TypeInt32,
+					Data: []byte{1, 0, 0, 0},
+				},
+				want: true,
+			},
+			{
+				name: "same type, different value",
+				expected: bsoncore.Value{
+					Type: bsoncore.TypeInt32,
+					Data: []byte{1, 0, 0, 0},
+				},
+				actual: bsoncore.Value{
+					Type: bsoncore.TypeInt32,
+					Data: []byte{1, 1, 1, 1},
+				},
+				want: false,
+			},
+			{
+				name: "same value, different type",
+				expected: bsoncore.Value{
+					Type: bsoncore.TypeDouble,
+					Data: []byte{1, 0, 0, 0, 0, 0, 0, 0},
+				},
+				actual: bsoncore.Value{
+					Type: bsoncore.TypeInt64,
+					Data: []byte{1, 0, 0, 0, 0, 0, 0, 0},
+				},
+				want: false,
+			},
+			{
+				name: "different value, different type",
+				expected: bsoncore.Value{
+					Type: bsoncore.TypeInt32,
+					Data: []byte{1, 0, 0, 0},
+				},
+				actual: bsoncore.Value{
+					Type: bsoncore.TypeString,
+					Data: []byte{1, 1, 1, 1},
+				},
+				want: false,
+			},
+			{
+				name: "invalid",
+				expected: bsoncore.Value{
+					Type: bsoncore.TypeInt64,
+					Data: []byte{1, 0, 0, 0},
+				},
+				actual: bsoncore.Value{
+					Type: bsoncore.TypeInt32,
+					Data: []byte{1, 0, 0, 0},
+				},
+				want: false,
+			},
+			{
+				name:     "empty",
+				expected: bsoncore.Value{},
+				actual:   bsoncore.Value{},
+				want:     true,
+			},
+		}
+
+		for _, tc := range testCases {
+			tc := tc // Capture range variable.
+
+			t.Run(tc.name, func(t *testing.T) {
+				t.Parallel()
+
+				got := EqualValue(new(testing.T), tc.expected, tc.actual)
+				if got != tc.want {
+					t.Errorf("EqualValue(%#v, %#v) = %v, want %v", tc.expected, tc.actual, got, tc.want)
+				}
+			})
+		}
+	})
+}