fix(bundle/definition): add custom validator for contentEncoding

bundle/definition/schema.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
-	"github.com/qri-io/jsonschema"
 )
 
 type Definitions map[string]*Schema
@@ -96,7 +95,7 @@ func (s *Schema) UnmarshalJSON(data []byte) error {
 	// Before we unmarshal into the cnab-go bundle/definition/Schema type, unmarshal into
 	// the library struct so we can handle any validation errors in the schema. If there
 	// are any errors, return those.
-	js := new(jsonschema.RootSchema)
+	js := NewRootSchema()
 	if err := js.UnmarshalJSON(data); err != nil {
 		return err
 	}

bundle/definition/validation.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 
 	"github.com/pkg/errors"
-	"github.com/qri-io/jsonschema"
 )
 
 // ValidationError error represents a validation error
@@ -24,7 +23,7 @@ func (s *Schema) Validate(data interface{}) ([]ValidationError, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to load schema")
 	}
-	def := new(jsonschema.RootSchema)
+	def := NewRootSchema()
 	err = json.Unmarshal([]byte(b), def)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to build schema")

bundle/definition/validation_test.go

@@ -42,6 +42,39 @@ func TestObjectValidationValid(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestObjectValidationValid_CustomValidator(t *testing.T) {
+	s := `{
+		"type": "object",
+		"properties" : {
+			"file" : {
+				"type": "string",
+				"contentEncoding": "base64"
+			}
+		},
+		"required" : ["file"]
+	}`
+	definition := new(Schema)
+	err := json.Unmarshal([]byte(s), definition)
+	require.NoError(t, err, "should have been able to marshal definition")
+	assert.Equal(t, "object", definition.Type, "type should have been an object")
+	props := definition.Properties
+	assert.NotNil(t, props, "should have found properties")
+	assert.Equal(t, 1, len(props), "should have had a single property")
+	propSchema, ok := props["file"]
+	assert.True(t, ok, "should have found file property")
+	assert.Equal(t, "string", propSchema.Type, "file type should have been a string")
+	assert.Equal(t, "base64", propSchema.ContentEncoding, "file contentEncoding should have been base64")
+
+	val := struct {
+		File string `json:"file"`
+	}{
+		File: "SGVsbG8gV29ybGQhCg==",
+	}
+	valErrors, err := definition.Validate(val)
+	assert.Len(t, valErrors, 0, "expected no validation errors")
+	assert.NoError(t, err)
+}
+
 func TestObjectValidationInValidMinimum(t *testing.T) {
 	s := `{
 		"type": "object",

bundle/definition/validators.go

@@ -0,0 +1,29 @@
+package definition
+
+import (
+	"github.com/qri-io/jsonschema"
+)
+
+// ContentEncoding represents a "custom" Schema property
+type ContentEncoding string
+
+// NewContentEncoding allocates a new ContentEncoding validator
+func NewContentEncoding() jsonschema.Validator {
+	return new(ContentEncoding)
+}
+
+// Validate implements the Validator interface for ContentEncoding
+// Currently, this is a no-op and is only used to register with the jsonschema library
+// that 'contentEncoding' is a valid property (as of writing, it isn't one of the defaults)
+func (c ContentEncoding) Validate(propPath string, data interface{}, errs *[]jsonschema.ValError) {}
+
+// NewRootSchema returns a jsonschema.RootSchema with any needed custom
+// jsonschema.Validators pre-registered
+func NewRootSchema() *jsonschema.RootSchema {
+	// Register custom validators here
+	// Note: as of writing, jsonschema doesn't have a stock validator for intances of type `contentEncoding`
+	// There may be others missing in the library that exist in http://json-schema.org/draft-07/schema#
+	// and thus, we'd need to create/register them here (if not included upstream)
+	jsonschema.RegisterValidator("contentEncoding", NewContentEncoding)
+	return new(jsonschema.RootSchema)
+}