tuned coverage

Author: daveshanley

openapi_vocabulary/discriminator.go

@@ -13,17 +13,11 @@ type discriminatorExtension struct {
 	mapping      map[string]string // value -> schema reference
 }
 
+// Validate validates the discriminator property exists in the instance
 func (d *discriminatorExtension) Validate(ctx *jsonschema.ValidatorContext, v any) {
-	// Validate that discriminator structure is correct
-	// For now, we only validate the structure, not the discriminator semantics
-	// Full discriminator validation would require schema resolution which is complex
+	obj, _ := v.(map[string]any)
 
-	obj, ok := v.(map[string]any)
-	if !ok {
-		return // discriminator only applies to objects
-	}
-
-	// Check if discriminator property exists in the object
+	// check if discriminator property exists in the object
 	if d.propertyName != "" {
 		if _, exists := obj[d.propertyName]; !exists {
 			ctx.AddError(&DiscriminatorPropertyMissingError{
@@ -33,14 +27,13 @@ func (d *discriminatorExtension) Validate(ctx *jsonschema.ValidatorContext, v an
 	}
 }
 
-// compileDiscriminator compiles the discriminator keyword
-func CompileDiscriminator(ctx *jsonschema.CompilerContext, obj map[string]any, version VersionType) (jsonschema.SchemaExt, error) {
+// CompileDiscriminator compiles the OpenAPI discriminator keyword
+func CompileDiscriminator(_ *jsonschema.CompilerContext, obj map[string]any, _ VersionType) (jsonschema.SchemaExt, error) {
 	v, exists := obj["discriminator"]
 	if !exists {
 		return nil, nil
 	}
 
-	// Validate discriminator structure
 	discriminator, ok := v.(map[string]any)
 	if !ok {
 		return nil, &OpenAPIKeywordError{
@@ -49,7 +42,6 @@ func CompileDiscriminator(ctx *jsonschema.CompilerContext, obj map[string]any, v
 		}
 	}
 
-	// Extract propertyName (required)
 	propertyNameValue, exists := discriminator["propertyName"]
 	if !exists {
 		return nil, &OpenAPIKeywordError{
@@ -66,7 +58,6 @@ func CompileDiscriminator(ctx *jsonschema.CompilerContext, obj map[string]any, v
 		}
 	}
 
-	// Extract mapping (optional)
 	var mapping map[string]string
 	if mappingValue, exists := discriminator["mapping"]; exists {
 		mappingObj, ok := mappingValue.(map[string]any)

openapi_vocabulary/vocabulary.go

@@ -38,45 +38,43 @@ func NewOpenAPIVocabularyWithCoercion(version VersionType, allowCoercion bool) *
 }
 
 // compileOpenAPIKeywords compiles all OpenAPI-specific keywords found in the schema object
-func compileOpenAPIKeywords(ctx *jsonschema.CompilerContext, obj map[string]any, version VersionType, allowCoercion bool) (jsonschema.SchemaExt, error) {
+func compileOpenAPIKeywords(ctx *jsonschema.CompilerContext,
+	obj map[string]any,
+	version VersionType,
+	allowCoercion bool) (jsonschema.SchemaExt, error) {
+
 	var extensions []jsonschema.SchemaExt
 
-	// Handle nullable keyword
 	if ext, err := CompileNullable(ctx, obj, version); err != nil {
 		return nil, err
 	} else if ext != nil {
 		extensions = append(extensions, ext)
 	}
 
-	// Handle discriminator keyword
 	if ext, err := CompileDiscriminator(ctx, obj, version); err != nil {
 		return nil, err
 	} else if ext != nil {
 		extensions = append(extensions, ext)
 	}
 
-	// Handle example keyword
 	if ext, err := CompileExample(ctx, obj, version); err != nil {
 		return nil, err
 	} else if ext != nil {
 		extensions = append(extensions, ext)
 	}
 
-	// Handle deprecated keyword
 	if ext, err := CompileDeprecated(ctx, obj, version); err != nil {
 		return nil, err
 	} else if ext != nil {
 		extensions = append(extensions, ext)
 	}
 
-	// Handle scalar coercion (applies to all schemas with coercible types)
 	if ext, err := CompileCoercion(ctx, obj, allowCoercion); err != nil {
 		return nil, err
 	} else if ext != nil {
 		extensions = append(extensions, ext)
 	}
 
-	// Return combined extension if any keywords were found
 	if len(extensions) == 0 {
 		return nil, nil
 	}

openapi_vocabulary/vocabulary_test.go

@@ -703,7 +703,10 @@ func TestDiscriminatorValidation_NonObjectValue(t *testing.T) {
 	schemaJSON := `{
 		"type": "object",
 		"discriminator": {
-			"propertyName": "type"
+			"propertyName": "type",
+             "mapping": {
+                "dog": "#/components/schemas/Dog",  
+            }
 		}
 	}`
 
@@ -726,3 +729,53 @@ func TestDiscriminatorValidation_NonObjectValue(t *testing.T) {
 	// Should get type validation error, not discriminator error
 	assert.NotContains(t, err.Error(), "discriminator property")
 }
+
+func TestDiscriminatorValidation_DiscriminatorBadMapping(t *testing.T) {
+	schemaJSON := `{
+		"type": "object",
+		"discriminator": {
+			"propertyName": "type",
+             "mapping": "not an object"
+		}
+	}`
+
+	schema, err := jsonschema.UnmarshalJSON(strings.NewReader(schemaJSON))
+	assert.NoError(t, err)
+
+	compiler := jsonschema.NewCompiler()
+	compiler.RegisterVocabulary(NewOpenAPIVocabulary(Version30))
+	compiler.AssertVocabs()
+
+	err = compiler.AddResource("test.json", schema)
+	assert.NoError(t, err)
+
+	_, err = compiler.Compile("test.json")
+	assert.Error(t, err)
+	assert.Equal(t, "OpenAPI keyword 'discriminator': discriminator mapping must be an object", err.Error())
+}
+
+func TestDiscriminatorValidation_BadMappingType(t *testing.T) {
+	schemaJSON := `{
+		"type": "object",
+		"discriminator": {
+			"propertyName": "type",
+             "mapping": {
+                "fish":  12345  
+            }
+		}
+	}`
+
+	schema, err := jsonschema.UnmarshalJSON(strings.NewReader(schemaJSON))
+	assert.NoError(t, err)
+
+	compiler := jsonschema.NewCompiler()
+	compiler.RegisterVocabulary(NewOpenAPIVocabulary(Version30))
+	compiler.AssertVocabs()
+
+	err = compiler.AddResource("test.json", schema)
+	assert.NoError(t, err)
+
+	_, err = compiler.Compile("test.json")
+	assert.Error(t, err)
+	assert.Equal(t, "OpenAPI keyword 'discriminator': discriminator mapping values must be strings", err.Error())
+}