Underlying type fix

schema/oneof.go

@@ -71,7 +71,7 @@ func (o OneOfSchema[KeyType]) UnserializeType(data any) (result any, err error)
 	if reflectedValue.Kind() != reflect.Map {
 		return result, &ConstraintError{
 			Message: fmt.Sprintf(
-				"Invalid type for one-of type: '%s'. Expected map.",
+				"Invalid type for one-of type: %q. Expected map.",
 				reflect.TypeOf(data).Name(),
 			),
 		}
@@ -114,28 +114,23 @@ func (o OneOfSchema[KeyType]) UnserializeType(data any) (result any, err error)
 		}
 		return result, &ConstraintError{
 			Message: fmt.Sprintf(
-				"Invalid value for '%s', expected one of: %s",
+				"Invalid value for %q, expected one of: %s",
 				o.DiscriminatorFieldNameValue,
 				strings.Join(validDiscriminators, ", "),
 			),
 		}
 	}
 
-	cloneData := maps.Clone(typedData)
-	if !o.DiscriminatorInlined {
-		delete(cloneData, o.DiscriminatorFieldNameValue)
-	}
+	cloneData := o.deleteDiscriminator(typedData)
 	unserializedData, err := selectedType.Unserialize(cloneData)
 	if err != nil {
 		return result, err
 	}
-
 	unserializedMap, ok := unserializedData.(map[string]any)
 	if ok {
 		unserializedMap[o.DiscriminatorFieldNameValue] = discriminator
 		return unserializedMap, nil
 	}
-
 	return saveConvertTo(unserializedData, o.ReflectedType())
 }
 
@@ -146,11 +141,7 @@ func (o OneOfSchema[KeyType]) ValidateType(data any) error {
 	}
 	dataMap, ok := data.(map[string]any)
 	if ok {
-		cloneData := maps.Clone(dataMap)
-		if !o.DiscriminatorInlined {
-			delete(cloneData, o.DiscriminatorFieldNameValue)
-		}
-		data = cloneData
+		data = o.deleteDiscriminator(dataMap)
 	}
 	if err := underlyingType.Validate(data); err != nil {
 		return ConstraintErrorAddPathSegment(err, fmt.Sprintf("{oneof[%v]}", discriminatorValue))
@@ -165,11 +156,7 @@ func (o OneOfSchema[KeyType]) SerializeType(data any) (any, error) {
 	}
 	dataMap, ok := data.(map[string]any)
 	if ok {
-		cloneData := maps.Clone(dataMap)
-		if !o.DiscriminatorInlined {
-			delete(cloneData, o.DiscriminatorFieldNameValue)
-		}
-		data = cloneData
+		data = o.deleteDiscriminator(dataMap)
 	}
 	serializedData, err := underlyingType.Serialize(data)
 	if err != nil {
@@ -280,11 +267,7 @@ func (o OneOfSchema[KeyType]) validateMap(data map[string]any) (KeyType, Object,
 				selectedTypeIDAsserted, o.getTypeValues()),
 		}
 	}
-	cloneData := maps.Clone(data)
-	if !o.DiscriminatorInlined { // Check to see if the discriminator is part of the sub-object.
-		delete(cloneData, o.DiscriminatorFieldNameValue) // The discriminator isn't part of the object.
-	}
-
+	cloneData := o.deleteDiscriminator(data)
 	err := selectedSchema.ValidateCompatibility(cloneData)
 	if err != nil {
 		return nilKey, nil, &ConstraintError{
@@ -367,7 +350,7 @@ func (o OneOfSchema[KeyType]) findUnderlyingType(data any) (KeyType, Object, err
 
 		return nilKey, nil, &ConstraintError{
 			Message: fmt.Sprintf(
-				"Invalid type for one-of type: '%s' expected struct or map.",
+				"Invalid type for one-of type: %q expected struct or map.",
 				reflect.TypeOf(data).Name(),
 			),
 		}
@@ -381,7 +364,6 @@ func (o OneOfSchema[KeyType]) findUnderlyingType(data any) (KeyType, Object, err
 		}
 		return myKey, mySchemaObj, nil
 	}
-	// else
 	for key, ref := range o.TypesValue {
 		underlyingReflectedType := ref.ReflectedType()
 		if underlyingReflectedType == reflectedType {
@@ -435,3 +417,13 @@ func (o OneOfSchema[KeyType]) validateSubtypeDiscriminatorInlineFields() error {
 	}
 	return nil
 }
+
+func (o OneOfSchema[KeyType]) deleteDiscriminator(mymap map[string]any) map[string]any {
+	// the discriminator is not a property of the subtype
+	if !o.DiscriminatorInlined {
+		cloneData := maps.Clone(mymap)
+		delete(cloneData, o.DiscriminatorFieldNameValue)
+		return cloneData
+	}
+	return mymap
+}

schema/oneof_string.go

@@ -1,8 +1,6 @@
 package schema
 
-import (
-	"reflect"
-)
+import "reflect"
 
 // OneOfString holds the definition of variable types with an integer discriminator. This type acts as a split for a
 // case where multiple possible object types can be present in a field. This type requires that there be a common field

schema/oneof_string_test.go

@@ -7,6 +7,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"go.arcalot.io/assert"
+	"reflect"
 	"testing"
 
 	"go.flow.arcalot.io/pluginsdk/schema"
@@ -145,11 +146,11 @@ var oneOfStringTestObjectAType = schema.NewScopeSchema(
 
 func TestOneOfStringUnserialization(t *testing.T) {
 	data := `{
-	"s": {
-		"_type": "B",
-		"message": "Hello world!"
-	}
-}`
+		"s": {
+			"_type": "B",
+			"message": "Hello world!"
+		}
+	}`
 	var input any
 	assert.NoError(t, json.Unmarshal([]byte(data), &input))
 	unserializedData, err := oneOfStringTestObjectAType.Unserialize(input)
@@ -163,7 +164,6 @@ func TestOneOfStringUnserialization(t *testing.T) {
 
 	// Not explicitly using a struct mapped object, but the type is inferred
 	// by the compiler when the oneOfTestBMappedSchema is in the test suite.
-	assert.NoError(t, json.Unmarshal([]byte(data), &input))
 	unserializedData, err = oneOfStringTestObjectASchema.Unserialize(input)
 	assert.NoError(t, err)
 	assert.Equals(t, unserializedData.(map[string]any)["s"].(oneOfTestObjectB).Message, "Hello world!")
@@ -247,75 +247,6 @@ func TestOneOfStringCompatibilityMapValidation(t *testing.T) {
 	assert.Error(t, oneOfStringTestObjectASchema.ValidateCompatibility(combinedMapAndInvalidSchema))
 }
 
-var oneOfStringTestInlineObjectAProperties = map[string]*schema.PropertySchema{
-	"s": schema.NewPropertySchema(
-		schema.NewOneOfStringSchema[any](
-			map[string]schema.Object{
-				"B": schema.NewRefSchema("B", nil),
-				"C": schema.NewRefSchema("C", nil),
-			},
-			"choice",
-			true,
-		),
-		nil,
-		true,
-		nil,
-		nil,
-		nil,
-		nil,
-		nil,
-	),
-}
-
-var oneOfStringTestInlineObjectAType = schema.NewScopeSchema(
-	schema.NewStructMappedObjectSchema[oneOfTestObjectA](
-		"A",
-		oneOfStringTestInlineObjectAProperties,
-	),
-	oneOfTestInlineBMappedSchema,
-	oneOfTestInlineCMappedSchema,
-)
-
-var oneOfStringTestInlineObjectASchema = schema.NewScopeSchema(
-	schema.NewObjectSchema(
-		"A",
-		oneOfStringTestInlineObjectAProperties,
-	),
-	oneOfTestInlineBSchema,
-	oneOfTestInlineCSchema,
-)
-
-func TestOneOfStringInline_Unserialization(t *testing.T) {
-	data := `{
-	"s": {
-		"choice": "B",
-		"message": "Hello world!"
-	}
-}`
-	var input any
-	assert.NoError(t, json.Unmarshal([]byte(data), &input))
-	unserializedData, err := oneOfStringTestInlineObjectAType.Unserialize(input)
-	assert.NoError(t, err)
-	assert.Equals(t, unserializedData.(oneOfTestObjectA).S.(oneOfTestInlineObjectB).Message, "Hello world!")
-	serialized, err := oneOfStringTestInlineObjectAType.Serialize(unserializedData)
-	assert.NoError(t, err)
-	unserialized2, err := oneOfStringTestInlineObjectAType.Unserialize(serialized)
-	assert.NoError(t, err)
-	assert.Equals(t, unserialized2, unserializedData)
-
-	// Not explicitly using a struct mapped object, but the type is inferred
-	// by the compiler when the oneOfTestBMappedSchema is in the test suite.
-	assert.NoError(t, json.Unmarshal([]byte(data), &input))
-	unserializedData, err = oneOfStringTestInlineObjectASchema.Unserialize(input)
-	assert.NoError(t, err)
-	assert.Equals(t, unserializedData.(map[string]any)["s"].(oneOfTestInlineObjectB).Message, "Hello world!")
-	serialized, err = oneOfStringTestInlineObjectASchema.Serialize(unserializedData)
-	assert.NoError(t, err)
-	unserialized2, err = oneOfStringTestInlineObjectASchema.Unserialize(serialized)
-	assert.NoError(t, err)
-	assert.Equals(t, unserialized2, unserializedData)
-}
-
 type inlinedTestObjectA struct {
 	DType       string `json:"d_type"`
 	OtherFieldA string `json:"other_field_a"`
@@ -505,6 +436,25 @@ func TestOneOf_NonInlinedNonStructMapped(t *testing.T) {
 	reserializedData := assert.NoErrorR[any](t)(oneofSchema.Serialize(unserializedData))
 	assert.Equals[any](t, reserializedData, serializedData)
 
+	var input_mismatched_type any = struct{}{}
+	err := oneofSchema.Validate(input_mismatched_type)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "Invalid type for one-of schema")
+
+	var input_invalid_type any = true
+	error_msg := fmt.Sprintf("Invalid type for one-of type: %q. Expected map.", reflect.TypeOf(input_invalid_type).Kind())
+	_, err = oneofSchema.Unserialize(input_invalid_type)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), error_msg)
+	error_msg = fmt.Sprintf("Invalid type for one-of type: %q expected struct or map.", reflect.TypeOf(input_invalid_type).Kind())
+	err = oneofSchema.Validate(input_invalid_type)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), error_msg)
+
+	var input_nil any = nil
+	_, err = oneofSchema.Unserialize(input_nil)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "bug: data is nil")
 }
 
 type inlinedTestIntDiscriminatorA struct {