Add more tests

lib/debezium/decimal.go

@@ -46,7 +46,7 @@ func EncodeDecimal(value string, scale int) []byte {
 }
 
 // DecodeDecimal is used to decode `org.apache.kafka.connect.data.Decimal`.
-func DecodeDecimal(data []byte, precision *int, scale int) (*decimal.Decimal, error) {
+func DecodeDecimal(data []byte, precision *int, scale int) *decimal.Decimal {
 	bigInt := new(big.Int)
 
 	// If the data represents a negative number, the sign bit will be set.
@@ -75,5 +75,5 @@ func DecodeDecimal(data []byte, precision *int, scale int) (*decimal.Decimal, er
 
 	// Perform the division
 	bigFloat.Quo(bigFloat, divisorFloat)
-	return decimal.NewDecimal(precision, scale, bigFloat), nil
+	return decimal.NewDecimal(precision, scale, bigFloat)
 }

lib/debezium/decimal_test.go

@@ -69,9 +69,8 @@ func TestEncodeDecimal(t *testing.T) {
 	}
 
 	for _, tc := range tcs {
-		actualEncodedValue := EncodeDecimal(tc.value, tc.scale)
-		decodedValue, err := DecodeDecimal(actualEncodedValue, nil, tc.scale)
-		assert.NoError(t, err, tc.name)
+		encodedValue := EncodeDecimal(tc.value, tc.scale)
+		decodedValue := DecodeDecimal(encodedValue, nil, tc.scale)
 		assert.Equal(t, tc.value, decodedValue.String(), tc.name)
 	}
 }

lib/debezium/types.go

@@ -148,7 +148,7 @@ func (f Field) DecodeDecimal(encoded []byte) (*decimal.Decimal, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to get scale and/or precision: %w", err)
 	}
-	return DecodeDecimal(encoded, results.Precision, results.Scale)
+	return DecodeDecimal(encoded, results.Precision, results.Scale), nil
 }
 
 func (f Field) DecodeDebeziumVariableDecimal(value any) (*decimal.Decimal, error) {

lib/debezium/types_test.go

@@ -273,26 +273,26 @@ func TestDecodeDebeziumVariableDecimal(t *testing.T) {
 		name        string
 		value       any
 		expectValue string
-		expectError bool
+		expectError string
 		expectScale int
 	}
 
 	testCases := []_testCase{
 		{
 			name:        "empty val (nil)",
-			expectError: true,
+			expectError: "value is not map[string]any type",
 		},
 		{
 			name:        "empty map",
 			value:       map[string]any{},
-			expectError: true,
+			expectError: "object is empty",
 		},
 		{
 			name: "scale is not an integer",
 			value: map[string]any{
 				"scale": "foo",
 			},
-			expectError: true,
+			expectError: "key: scale is not type integer:",
 		},
 		{
 			name: "value exists (scale 3)",
@@ -321,13 +321,30 @@ func TestDecodeDebeziumVariableDecimal(t *testing.T) {
 			expectValue: "-105.2813669",
 			expectScale: 7,
 		},
+		{
+			name: "malformed base64 value",
+			value: map[string]any{
+				"scale": 7,
+				"value": "==wT9Wmw==",
+			},
+			expectError: "failed to base64 decode",
+		},
+		{
+			name: "[]byte value",
+			value: map[string]any{
+				"scale": 7,
+				"value": []byte{193, 63, 86, 155},
+			},
+			expectValue: "-105.2813669",
+			expectScale: 7,
+		},
 	}
 
 	for _, testCase := range testCases {
 		field := Field{}
 		dec, err := field.DecodeDebeziumVariableDecimal(testCase.value)
-		if testCase.expectError {
-			assert.Error(t, err, testCase.name)
+		if testCase.expectError != "" {
+			assert.ErrorContains(t, err, testCase.expectError, testCase.name)
 			continue
 		}