Add convenience function for "format" schema result parsing

The JSON schema validation result parsing infrastructure provides general purpose capabilities for identifying the
instance and schema pointers related to a validation failure. However, when a specific type of schema keyword is used in
multiple places, it is convenient to create a dedicated wrapper function to facilitate that use case. Previously the
"format" keyword was only used for one thing in the library.properties schemas, which made it not worth a convenience
function. The package index schema uses "format" keyword also, so it now becomes worthwhile having a convenience parsing
function for it.

Author: per1234

go.mod

@@ -43,7 +43,7 @@ require (
 	github.com/spf13/viper v1.7.1 // indirect
 	github.com/stretchr/testify v1.6.1
 	github.com/xanzy/ssh-agent v0.3.0 // indirect
-	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
+	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415
 	go.bug.st/relaxed-semver v0.0.0-20190922224835-391e10178d18
 	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.14.0 // indirect

internal/project/library/libraryproperties/librarypropertiesschemas_test.go

@@ -79,6 +79,19 @@ func checkPropertyEnumMismatch(propertyName string, testTables []propertyValueTe
 	}
 }
 
+func checkPropertyFormatMismatch(propertyName string, testTables []propertyValueTestTable, t *testing.T) {
+	libraryProperties := properties.NewFromHashmap(validLibraryPropertiesMap)
+	var validationResult map[compliancelevel.Type]schema.ValidationResult
+
+	for _, testTable := range testTables {
+		validationResult = changeValueUpdateValidationResult(propertyName, testTable.propertyValue, libraryProperties, validationResult)
+
+		t.Run(fmt.Sprintf("%s (%s)", testTable.testName, testTable.complianceLevel), func(t *testing.T) {
+			testTable.assertion(t, schema.PropertyFormatMismatch(propertyName, validationResult[testTable.complianceLevel]))
+		})
+	}
+}
+
 type validationErrorTestTable struct {
 	testName           string
 	propertyValue      string
@@ -322,13 +335,13 @@ func TestPropertiesCategoryEnum(t *testing.T) {
 }
 
 func TestPropertiesUrlFormat(t *testing.T) {
-	testTables := []validationErrorTestTable{
-		{"Invalid URL format", "foo", "/format$", compliancelevel.Permissive, assert.False},
-		{"Invalid URL format", "foo", "/format$", compliancelevel.Specification, assert.True},
-		{"Invalid URL format", "foo", "/format$", compliancelevel.Strict, assert.True},
+	testTables := []propertyValueTestTable{
+		{"Invalid URL format", "foo", compliancelevel.Permissive, assert.False},
+		{"Invalid URL format", "foo", compliancelevel.Specification, assert.True},
+		{"Invalid URL format", "foo", compliancelevel.Strict, assert.True},
 	}
 
-	checkValidationErrorMatch("url", testTables, t)
+	checkPropertyFormatMismatch("url", testTables, t)
 }
 
 func TestPropertiesDependsPattern(t *testing.T) {

internal/rule/schema/parsevalidationresult.go

@@ -54,6 +54,11 @@ func PropertyDependenciesMissing(propertyName string, validationResult Validatio
 	return ValidationErrorMatch("", "/dependencies/"+propertyName+"/[0-9]+$", "", "", validationResult)
 }
 
+// PropertyFormatMismatch returns whether the given property has incorrect format.
+func PropertyFormatMismatch(propertyName string, validationResult ValidationResult) bool {
+	return ValidationErrorMatch("^#/"+propertyName+"$", "/format$", "", "", validationResult)
+}
+
 // MisspelledOptionalPropertyFound returns whether a misspelled optional property was found.
 func MisspelledOptionalPropertyFound(validationResult ValidationResult) bool {
 	return ValidationErrorMatch("#/", "/misspelledOptionalProperties/", "", "", validationResult)

internal/rule/schema/schema_test.go

@@ -16,6 +16,8 @@
 package schema
 
 import (
+	"encoding/json"
+	"fmt"
 	"regexp"
 	"testing"
 
@@ -25,6 +27,7 @@ import (
 	"github.com/ory/jsonschema/v3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/xeipuuv/gojsonpointer"
 )
 
 var validMap = map[string]string{
@@ -150,6 +153,29 @@ func TestPropertyEnumMismatch(t *testing.T) {
 	assert.True(t, PropertyEnumMismatch("property3", validationResult))
 }
 
+func TestPropertyFormatMismatch(t *testing.T) {
+	propertyName := "TestPropertyFormatMismatch"
+	instanceTemplate := `
+{
+	"%s": "http://example.com"
+}
+`
+	rawInstance := fmt.Sprintf(instanceTemplate, propertyName)
+	var instance map[string]interface{}
+	json.Unmarshal([]byte(rawInstance), &instance)
+
+	assert.False(t, PropertyFormatMismatch(propertyName, Validate(instance, validSchemaWithReferences)), "Property format is correct")
+
+	// Change property to incorrect type.
+	pointerString := "/" + propertyName
+	pointer, err := gojsonpointer.NewJsonPointer(pointerString)
+	require.NoError(t, err)
+	_, err = pointer.Set(instance, "foo")
+	require.NoError(t, err)
+
+	assert.True(t, PropertyFormatMismatch(propertyName, Validate(instance, validSchemaWithReferences)), "Property format is incorrect")
+}
+
 func TestPropertyDependenciesMissing(t *testing.T) {
 	propertiesMap := properties.NewFromHashmap(validMap)
 	validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)

internal/rule/schema/testdata/bindata.go

@@ -138,6 +138,11 @@ var _referencedSchema2Json = []byte(`{
         ]
       }
     },
+    "TestPropertyFormatMismatch": {
+      "object": {
+        "format": "uri"
+      }
+    },
     "misspelledOptionalProperties": {
       "propertyNames": {
         "not": {
@@ -217,6 +222,13 @@ var _validSchemaWithReferencesJson = []byte(`{
           "$ref": "referenced-schema-2.json#/definitions/notPatternObject"
         }
       ]
+    },
+    "TestPropertyFormatMismatch": {
+      "allOf": [
+        {
+          "$ref": "referenced-schema-2.json#/definitions/TestPropertyFormatMismatch/object"
+        }
+      ]
     }
   },
   "allOf": [

internal/rule/schema/testdata/input/referenced-schema-2.json

@@ -26,6 +26,11 @@
         ]
       }
     },
+    "TestPropertyFormatMismatch": {
+      "object": {
+        "format": "uri"
+      }
+    },
     "misspelledOptionalProperties": {
       "propertyNames": {
         "not": {

internal/rule/schema/testdata/input/valid-schema-with-references.json

@@ -30,6 +30,13 @@
           "$ref": "referenced-schema-2.json#/definitions/notPatternObject"
         }
       ]
+    },
+    "TestPropertyFormatMismatch": {
+      "allOf": [
+        {
+          "$ref": "referenced-schema-2.json#/definitions/TestPropertyFormatMismatch/object"
+        }
+      ]
     }
   },
   "allOf": [