dato_json_schema 0.20.8

data/test/json_schema/document_store_test.rb

@@ -0,0 +1,42 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::DocumentStore do
+  before do
+    @store = JsonSchema::DocumentStore.new
+  end
+
+  it "adds and looks up a schema" do
+    schema = schema_sample("http://example.com/schema")
+    @store.add_schema(schema)
+    assert_equal schema, @store.lookup_schema(schema.uri)
+  end
+
+  it "can iterate through its schemas" do
+    uri = "http://example.com/schema"
+    schema = schema_sample(uri)
+    @store.add_schema(schema)
+    assert_equal [[uri, schema]], @store.to_a
+  end
+
+  it "can lookup a schema added with a document root sign" do
+    uri = "http://example.com/schema"
+    schema = schema_sample(uri + "#")
+    @store.add_schema(schema)
+    assert_equal schema, @store.lookup_schema(uri)
+  end
+
+  it "can lookup a schema with a document root sign" do
+    uri = "http://example.com/schema"
+    schema = schema_sample(uri)
+    @store.add_schema(schema)
+    assert_equal schema, @store.lookup_schema(uri + "#")
+  end
+
+  def schema_sample(uri)
+    schema = JsonSchema::Schema.new
+    schema.uri = uri
+    schema
+  end
+end

data/test/json_schema/error_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::SchemaError do
+  it "can print a message with a pointer" do
+    schema = JsonSchema::Schema.new
+    schema.fragment = "#"
+
+    e = JsonSchema::SchemaError.new(schema, "problem", nil)
+    assert_equal "#: problem", e.to_s
+  end
+
+  it "can print a message without a pointer" do
+    e = JsonSchema::SchemaError.new(nil, "problem", nil)
+    assert_equal "problem", e.to_s
+  end
+end

data/test/json_schema/parser_test.rb

@@ -0,0 +1,362 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::Parser do
+  after do
+    JsonSchema.configuration.reset!
+  end
+
+  it "parses the basic attributes of a schema" do
+    schema = parse
+    assert_nil schema.id
+    assert_equal "Example API", schema.title
+    assert_equal "An example API.", schema.description
+    assert_equal ["object"], schema.type
+    assert_equal "/", schema.uri
+  end
+
+  it "parses subschemas" do
+    schema = parse.definitions["app"]
+    assert_nil schema.reference
+    assert_equal "App", schema.title
+    assert_equal "An app.", schema.description
+    assert_equal "schemata/app", schema.id
+    assert_equal ["object"], schema.type
+    assert_equal "/schemata/app", schema.uri
+    refute_nil schema.parent
+  end
+
+  it "parses sub-subschemas" do
+    schema = parse.definitions["app"].definitions["name"]
+    assert_nil schema.reference
+    assert_equal "hello-world", schema.default
+    assert_equal "unique name of app", schema.description
+    assert_equal ["string"], schema.type
+    assert_equal "/schemata/app", schema.uri
+    refute_nil schema.parent
+  end
+
+  it "parses references" do
+    schema = parse.properties["app"]
+    refute_nil schema.reference
+    assert_nil schema.reference.uri
+    assert_equal "#/definitions/app", schema.reference.pointer
+    refute_nil schema.parent
+  end
+
+  it "parses enum validation" do
+    schema = parse.definitions["app"].definitions["visibility"]
+    assert_equal ["private", "public"], schema.enum
+  end
+
+  it "parses array validations" do
+    schema = parse.definitions["app"].definitions["flags"]
+    assert_equal(/^[a-z][a-z\-]*[a-z]$/, schema.items.pattern)
+    assert_equal 1, schema.min_items
+    assert_equal 10, schema.max_items
+    assert_equal true, schema.unique_items
+  end
+
+  it "parses array items tuple validation" do
+    pointer("#/definitions/app/definitions/flags").merge!(
+      "items" => [
+        { "enum" => ["bamboo", "cedar"] },
+        { "enum" => ["http", "https"] }
+      ]
+    )
+    schema = parse.definitions["app"].definitions["flags"]
+    assert_equal ["bamboo", "cedar"], schema.items[0].enum
+    assert_equal ["http", "https"], schema.items[1].enum
+  end
+
+  it "parses array additionalItems object validation as boolean" do
+    pointer("#/definitions/app/definitions/flags").merge!(
+      "additionalItems" => false
+    )
+    schema = parse.definitions["app"].definitions["flags"]
+    assert_equal false, schema.additional_items
+  end
+
+  it "parses array additionalItems object validation as schema" do
+    pointer("#/definitions/app/definitions/flags").merge!(
+      "additionalItems" => {
+        "type" => "boolean"
+       }
+    )
+    schema = parse.definitions["app"].definitions["flags"].additional_items
+    assert_equal ["boolean"], schema.type
+  end
+
+  it "parses integer validations" do
+    schema = parse.definitions["app"].definitions["id"]
+    assert_equal 0, schema.min
+    assert_equal true, schema.min_exclusive
+    assert_equal 10000, schema.max
+    assert_equal false, schema.max_exclusive
+    assert_equal 1, schema.multiple_of
+  end
+
+  it "parses number validations" do
+    schema = parse.definitions["app"].definitions["cost"]
+    assert_equal 0.0, schema.min
+    assert_equal false, schema.min_exclusive
+    assert_equal 1000.0, schema.max
+    assert_equal true, schema.max_exclusive
+    assert_equal 0.01, schema.multiple_of
+  end
+
+  it "parses the basic set of object validations" do
+    schema = parse.definitions["app"]
+    assert_equal 10, schema.max_properties
+    assert_equal 1, schema.min_properties
+    assert_equal ["name"], schema.required
+  end
+
+  it "parses the additionalProperties object validation as boolean" do
+    pointer("#/definitions/app").merge!(
+      "additionalProperties" => false
+    )
+    schema = parse.definitions["app"]
+    assert_equal false, schema.additional_properties
+  end
+
+  it "parses the additionalProperties object validation as schema" do
+    pointer("#/definitions/app").merge!(
+      "additionalProperties" => {
+        "type" => "boolean"
+      }
+    )
+    schema = parse.definitions["app"].additional_properties
+    assert_equal ["boolean"], schema.type
+  end
+
+  it "parses the dependencies object validation" do
+    schema = parse.definitions["app"]
+    assert_equal ["ssl"], schema.dependencies["production"]
+    assert_equal 20.0, schema.dependencies["ssl"].properties["cost"].min
+  end
+
+  it "parses the patternProperties object validation" do
+    schema = parse.definitions["app"].definitions["config_vars"]
+    property = schema.pattern_properties.first
+    assert_equal(/^\w+$/, property[0])
+    assert_equal ["null", "string"], property[1].type
+  end
+
+  it "parses the strictProperties object validation" do
+    pointer("#/definitions/app").merge!(
+      "strictProperties" => true
+    )
+    schema = parse.definitions["app"]
+    assert_equal true, schema.strict_properties
+  end
+
+  # couldn't think of any non-contrived examples to work with here
+  it "parses the basic set of schema validations" do
+    schema = parse.definitions["app"].definitions["contrived"]
+    assert_equal 2, schema.all_of.count
+    assert_equal 2, schema.one_of.count
+    assert schema.not
+  end
+
+  it "parses the anyOf schema validation" do
+    schema = parse.definitions["app"].definitions["identity"]
+    assert_equal 2, schema.any_of.count
+    assert_equal "/schemata/app#/definitions/id", schema.any_of[0].reference.to_s
+    assert_equal "/schemata/app#/definitions/name", schema.any_of[1].reference.to_s
+  end
+
+  it "parses basic set of string validations" do
+    schema = parse.definitions["app"].definitions["name"]
+    assert_equal 30, schema.max_length
+    assert_equal 3, schema.min_length
+    assert_equal(/^[a-z][a-z0-9-]{3,30}$/, schema.pattern)
+  end
+
+  it "parses hypermedia links" do
+    pointer("#/definitions/app").merge!(
+      "links" => [
+        "description" => "Create a new app.",
+        "encType"    => "application/x-www-form-urlencoded",
+        "href" => "/apps",
+        "method" => "POST",
+        "rel" => "create",
+        "mediaType" => "application/json",
+        "schema" => {
+          "properties" => {
+            "name" => {
+              "$ref" => "#/definitions/app/definitions/name"
+            },
+          }
+        },
+        "targetSchema" => {
+          "$ref" => "#/definitions/app"
+        }
+      ]
+    )
+    schema = parse.definitions["app"]
+    link = schema.links[0]
+    assert_equal schema, link.parent
+    assert_equal "links/0", link.fragment
+    assert_equal "#/definitions/app/links/0", link.pointer
+    assert_equal "Create a new app.", link.description
+    assert_equal "application/x-www-form-urlencoded", link.enc_type
+    assert_equal "/apps", link.href
+    assert_equal :post, link.method
+    assert_equal "create", link.rel
+    assert_equal "application/json", link.media_type
+    assert_equal "#/definitions/app/definitions/name",
+      link.schema.properties["name"].reference.pointer
+  end
+
+  it "parses hypermedia media" do
+    pointer("#/definitions/app/media").merge!(
+      "binaryEncoding" => "base64",
+      "type"           => "image/png"
+    )
+    schema = parse.definitions["app"]
+    assert_equal "base64", schema.media.binary_encoding
+    assert_equal "image/png", schema.media.type
+  end
+
+  it "parses hypermedia pathStart" do
+    pointer("#/definitions/app").merge!(
+      "pathStart" => "/v2"
+    )
+    schema = parse.definitions["app"]
+    assert_equal "/v2", schema.path_start
+  end
+
+  it "parses hypermedia readOnly" do
+    pointer("#/definitions/app").merge!(
+      "readOnly" => true
+    )
+    schema = parse.definitions["app"]
+    assert_equal true, schema.read_only
+  end
+
+  it "builds appropriate JSON Pointers" do
+    schema = parse.definitions["app"].definitions["name"]
+    assert_equal "#/definitions/app/definitions/name", schema.pointer
+  end
+
+  it "errors on non-string ids" do
+    schema_sample["id"] = 4
+    refute parse
+    assert_includes error_messages,
+      %{4 is not a valid "id", must be a string.}
+    assert_includes error_types, :invalid_type
+  end
+
+  it "errors on non-string titles" do
+    schema_sample["title"] = 4
+    refute parse
+    assert_includes error_messages,
+      %{4 is not a valid "title", must be a string.}
+    assert_includes error_types, :invalid_type
+  end
+
+  it "errors on non-string descriptions" do
+    schema_sample["description"] = 4
+    refute parse
+    assert_includes error_messages,
+      %{4 is not a valid "description", must be a string.}
+    assert_includes error_types, :invalid_type
+  end
+
+  it "errors on non-array and non-string types" do
+    schema_sample["type"] = 4
+    refute parse
+    assert_includes error_messages,
+      %{4 is not a valid "type", must be a array/string.}
+    assert_includes error_types, :invalid_type
+  end
+
+  it "errors on unknown types" do
+    schema_sample["type"] = ["float", "double"]
+    refute parse
+    assert_includes error_messages, %{Unknown types: double, float.}
+    assert_includes error_types, :unknown_type
+  end
+
+  it "errors on unknown formats" do
+    schema_sample["format"] = "obscure-thing"
+    refute parse
+    assert_includes error_messages, '"obscure-thing" is not a valid format, ' \
+                                    'must be one of date, date-time, email, ' \
+                                    'hostname, ipv4, ipv6, regex, uri, ' \
+                                    'uri-reference, uuid.'
+    assert_includes error_types, :unknown_format
+  end
+
+  it "passes for an invalid regex when not asked to check" do
+    schema_sample["pattern"] = "\\Ameow"
+    assert parse
+  end
+
+  it "errors for an invalid regex when asked to check" do
+    require 'ecma-re-validator'
+    JsonSchema.configure do |c|
+      c.validate_regex_with = :'ecma-re-validator'
+    end
+    schema_sample["pattern"] = "\\Ameow"
+    refute parse
+    assert_includes error_messages, '"\\\\Ameow" is not an ECMA-262 regular expression.'
+    assert_includes error_types, :regex_failed
+  end
+
+  it "parses custom formats" do
+    JsonSchema.configure do |c|
+      c.register_format 'the-answer', ->(data) { data.to_i == 42 }
+    end
+    schema_sample["format"] = "the-answer"
+    assert parse
+  end
+
+  it "rejects bad formats even when there are custom formats defined" do
+    JsonSchema.configure do |c|
+      c.register_format "the-answer", ->(data) { data.to_i == 42 }
+    end
+    schema_sample["format"] = "not-a-format"
+    refute parse
+    assert_includes error_messages, '"not-a-format" is not a valid format, ' \
+                                    'must be one of date, date-time, email, ' \
+                                    'hostname, ipv4, ipv6, regex, uri, ' \
+                                    'uri-reference, uuid, the-answer.'
+    assert_includes error_types, :unknown_format
+  end
+
+  it "raises an aggregate error with parse!" do
+    schema_sample["id"] = 4
+
+    parser = JsonSchema::Parser.new
+
+    # don't bother checking the particulars of the error here because we have
+    # other tests for that above
+    assert_raises JsonSchema::AggregateError do
+      parser.parse!(schema_sample)
+    end
+  end
+
+  def error_messages
+    @parser.errors.map { |e| e.message }
+  end
+
+  def error_types
+    @parser.errors.map { |e| e.type }
+  end
+
+  def parse
+    @parser = JsonSchema::Parser.new
+    @parser.parse(schema_sample)
+  end
+
+  def pointer(path)
+    JsonPointer.evaluate(schema_sample, path)
+  end
+
+  def schema_sample
+    @schema_sample ||= DataScaffold.schema_sample
+  end
+end

data/test/json_schema/reference_expander_test.rb

@@ -0,0 +1,618 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::ReferenceExpander do
+  it "expands references" do
+    expand
+    assert_equal [], error_messages
+
+    # this was always a fully-defined property
+    referenced = @schema.definitions["app"]
+    # this used to be a $ref
+    reference = @schema.properties["app"]
+
+    assert_equal "#/definitions/app", reference.reference.pointer
+    assert_equal referenced.description, reference.description
+    assert_equal referenced.id, reference.id
+    assert_equal referenced.type, reference.type
+    assert_equal referenced.uri, reference.uri
+  end
+
+  it "takes a document store" do
+    store = JsonSchema::DocumentStore.new
+    expand(store: store)
+    assert_equal store, @expander.store
+  end
+
+  it "will expand anyOf" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].definitions["contrived_plus"]
+    assert_equal 3, schema.any_of[0].min_length
+    assert_equal 5, schema.any_of[1].min_length
+  end
+
+  it "will expand allOf" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].definitions["contrived_plus"]
+    assert_equal 30, schema.all_of[0].max_length
+    assert_equal 3, schema.all_of[1].min_length
+  end
+
+  it "will expand dependencies" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].dependencies["ssl"].properties["name"]
+    assert_equal ["string"], schema.type
+  end
+
+  it "will expand items list schema" do
+    pointer("#/definitions/app/definitions/flags").merge!(
+      "items" => {
+        "$ref" => "#/definitions/app/definitions/name"
+      }
+    )
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].properties["flags"].items
+    assert_equal ["string"], schema.type
+  end
+
+  it "will expand items tuple schema" do
+    pointer("#/definitions/app/definitions/flags").merge!(
+      "items" => [
+        { "$ref" => "#/definitions/app/definitions/name" },
+        { "$ref" => "#/definitions/app/definitions/owner" }
+      ]
+    )
+    expand
+    assert_equal [], error_messages
+    schema0 = @schema.properties["app"].properties["flags"].items[0]
+    schema1 = @schema.properties["app"].properties["flags"].items[0]
+    assert_equal ["string"], schema0.type
+    assert_equal ["string"], schema1.type
+  end
+
+  it "will expand oneOf" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].definitions["contrived_plus"]
+    assert_equal(/^(foo|aaa)$/, schema.one_of[0].pattern)
+    assert_equal(/^(foo|zzz)$/, schema.one_of[1].pattern)
+  end
+
+  it "will expand not" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].definitions["contrived_plus"]
+    assert_equal(/^$/, schema.not.pattern)
+  end
+
+  it "will expand additionalProperties" do
+    pointer("#").merge!(
+      "additionalProperties" => { "$ref" => "#" }
+    )
+    expand
+    assert_equal [], error_messages
+    schema = @schema.additional_properties
+    assert_equal ["object"], schema.type
+  end
+
+  it "will expand patternProperties" do
+    expand
+    assert_equal [], error_messages
+    # value ([1]) of the #first tuple in hash
+    schema = @schema.properties["app"].definitions["roles"].
+      pattern_properties.first[1]
+    assert_equal ["string"], schema.type
+  end
+
+  it "will expand hyperschema link schemas" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].links[0].schema.properties["name"]
+    assert_equal ["string"], schema.type
+  end
+
+  it "will expand hyperschema link targetSchemas" do
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"].links[0].target_schema.properties["name"]
+    assert_equal ["string"], schema.type
+  end
+
+  it "will perform multiple passes to resolve all references" do
+    pointer("#/properties").merge!(
+      "app0" => { "$ref" => "#/properties/app1" },
+      "app1" => { "$ref" => "#/properties/app2" },
+      "app2" => { "$ref" => "#/definitions/app" },
+    )
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app0"]
+    assert_equal ["object"], schema.type
+  end
+
+  it "will resolve circular dependencies" do
+    pointer("#/properties").merge!(
+      "app" => { "$ref" => "#" }
+    )
+    expand
+    assert_equal [], error_messages
+    schema = @schema.properties["app"]
+    assert_equal ["object"], schema.type
+  end
+
+  it "builds appropriate JSON Pointers for expanded references" do
+    expand
+    assert_equal [], error_messages
+
+    # the *referenced* schema should still have a proper pointer
+    schema = @schema.definitions["app"].definitions["name"]
+    assert_equal "#/definitions/app/definitions/name", schema.pointer
+
+    # the *reference* schema should have expanded a pointer
+    schema = @schema.properties["app"].properties["name"]
+    assert_equal "#/definitions/app/properties/name", schema.pointer
+  end
+
+  # clones are special in that they retain their original pointer despite where
+  # they've been nested
+  it "builds appropriate JSON Pointers for circular dependencies" do
+    pointer("#/properties").merge!(
+      "app"  => { "$ref" => "#" },
+      "app1" => { "$ref" => "#/properties/app"}
+    )
+    expand
+
+    # the first self reference has the standard pointer as expected
+    schema = @schema.properties["app"]
+    assert_equal "#/properties/app", schema.pointer
+
+    # but diving deeper results in the same pointer again
+    schema = schema.properties["app"]
+    assert_equal "#/properties/app", schema.pointer
+
+    schema = @schema.properties["app1"]
+    assert_equal "#/properties/app1", schema.pointer
+
+    schema = schema.properties["app1"]
+    assert_equal "#/properties/app1", schema.pointer
+  end
+
+  it "errors on a JSON Pointer that can't be resolved" do
+    pointer("#/properties").merge!(
+      "app" => { "$ref" => "#/definitions/nope" }
+    )
+    refute expand
+    assert_includes error_messages, %{Couldn't resolve pointer "#/definitions/nope".}
+    assert_includes error_types, :unresolved_pointer
+    assert_includes error_messages, %{Couldn't resolve references: #/definitions/nope.}
+    assert_includes error_types, :unresolved_references
+  end
+
+  it "errors on a URI that can't be resolved" do
+    pointer("#/properties").merge!(
+      "app" => { "$ref" => "/schemata/user#/definitions/name" }
+    )
+    refute expand
+    assert_includes error_messages,
+      %{Couldn't resolve references: /schemata/user#/definitions/name.}
+      assert_includes error_types, :unresolved_references
+    assert_includes error_messages, %{Couldn't resolve URI: /schemata/user.}
+    assert_includes error_types, :unresolved_pointer
+  end
+
+  it "errors on a relative URI that cannot be transformed to an absolute" do
+    pointer("#/properties").merge!(
+      "app" => { "$ref" => "relative#definitions/name" }
+    )
+    refute expand
+    assert_includes error_messages,
+      %{Couldn't resolve references: relative#definitions/name.}
+    assert_includes error_types, :unresolved_references
+  end
+
+  it "errors on a reference cycle" do
+    pointer("#/properties").merge!(
+      "app0" => { "$ref" => "#/properties/app2" },
+      "app1" => { "$ref" => "#/properties/app0" },
+      "app2" => { "$ref" => "#/properties/app1" },
+    )
+    refute expand
+    properties = "#/properties/app0, #/properties/app1, #/properties/app2"
+    assert_includes error_messages, %{Reference loop detected: #{properties}.}
+    assert_includes error_types, :loop_detected
+    assert_includes error_messages, %{Couldn't resolve references: #{properties}.}
+    assert_includes error_types, :unresolved_references
+  end
+
+  it "raises an aggregate error with expand!" do
+    pointer("#/properties").merge!(
+      "app" => { "$ref" => "#/definitions/nope" }
+    )
+
+    schema = JsonSchema::Parser.new.parse!(schema_sample)
+    expander = JsonSchema::ReferenceExpander.new
+
+    # don't bother checking the particulars of the error here because we have
+    # other tests for that above
+    assert_raises JsonSchema::AggregateError do
+      expander.expand!(schema)
+    end
+  end
+
+  it "expands a schema that is just a reference" do
+    # First initialize another schema. Give it a fully qualified URI so that we
+    # can reference it across schemas.
+    schema = JsonSchema::Parser.new.parse!(schema_sample)
+    schema.uri = "http://json-schema.org/test"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema)
+
+    # Have the parser parse _just_ a reference. It should resolve to a
+    # subschema in the schema that we initialized above.
+    schema = JsonSchema::Parser.new.parse!(
+      { "$ref" => "http://json-schema.org/test#/definitions/app" }
+    )
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand!(schema, store: store)
+
+    assert schema.expanded?
+  end
+
+  it "expands a schema with a reference to an external schema in a oneOf array" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "id" => "http://json-schema.org/draft-04/schema#",
+      "definitions" => {
+        "schemaArray" => {
+          "type" => "array",
+          "minItems" => 1,
+          "items" => { "$ref" => "#" }
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema#",
+      "id" => "http://json-schema.org/draft-04/hyper-schema#",
+      "allOf" => [
+        {
+          "$ref" => "http://json-schema.org/draft-04/schema#"
+        }
+      ]
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+
+    store = JsonSchema::DocumentStore.new
+    expander = JsonSchema::ReferenceExpander.new
+
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander.expand!(schema2, store: store)
+
+    assert schema1.expanded?
+    assert schema2.expanded?
+  end
+
+  it "expands a schema with a nested reference to an external schema in a oneOf array" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "id" => "http://json-schema.org/draft-04/schema#",
+      "definitions" => {
+        "thingy" => {
+          "type" => ["string"]
+        },
+        "schemaArray" => {
+          "type" => "array",
+          "minItems" => 1,
+          "items" => { "$ref" => "#/definitions/thingy" }
+        }
+      },
+      "properties" => {
+        "whatsit" => {
+          "$ref" => "#/definitions/schemaArray"
+        },
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema#",
+      "id" => "http://json-schema.org/draft-04/hyper-schema#",
+      "allOf" => [
+        {
+          "$ref" => "http://json-schema.org/draft-04/schema#"
+        }
+      ]
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+
+    store = JsonSchema::DocumentStore.new
+    expander = JsonSchema::ReferenceExpander.new
+
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander.expand!(schema2, store: store)
+
+    assert_equal ["string"], schema2.all_of[0].properties["whatsit"].items.type
+  end
+
+  it "expands a schema with a reference to an external schema with a nested external property reference" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "foo" => {
+          "$ref" => "http://json-schema.org/b.json#/definitions/bar"
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    schema1.uri = "http://json-schema.org/a.json"
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "definitions" => {
+        "bar" => {
+          "type" => "object",
+          "properties" => {
+            "omg" => {
+              "$ref" => "http://json-schema.org/c.json#/definitions/baz"
+            }
+          }
+        }
+      }
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+    schema2.uri = "http://json-schema.org/b.json"
+
+    sample3 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "definitions" => {
+        "baz" => {
+          "type" => "string",
+          "maxLength" => 3
+        }
+      }
+    }
+    schema3 = JsonSchema::Parser.new.parse!(sample3)
+    schema3.uri = "http://json-schema.org/c.json"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+    store.add_schema(schema3)
+
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand!(schema1, store: store)
+
+    assert_equal 3, schema1.properties["foo"].properties["omg"].max_length
+  end
+
+  it "it handles oneOf with nested references to an external schema" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "foo" => {
+          "$ref" => "http://json-schema.org/b.json#"
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    schema1.uri = "http://json-schema.org/a.json"
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "bar" => {
+          "oneOf" => [
+            {"type" => "null"},
+            {"$ref" => "http://json-schema.org/c.json#"}
+          ]
+        }
+      },
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+    schema2.uri = "http://json-schema.org/b.json"
+
+    sample3 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "baz" => {
+          "type" => "string",
+          "maxLength" => 3
+        }
+      }
+    }
+    schema3 = JsonSchema::Parser.new.parse!(sample3)
+    schema3.uri = "http://json-schema.org/c.json"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+    store.add_schema(schema3)
+
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand(schema1, store: store)
+
+    assert_equal 3, schema1.properties["foo"].properties["bar"].one_of[1].properties["baz"].max_length
+  end
+
+  it "does not infinitely recurse when external ref is local to its schema" do
+    sample1 = {
+      "id" => "http://json-schema.org/draft-04/schema#",
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "properties" => {
+        "additionalItems" => {
+          "anyOf" => [ { "$ref" => "#" } ]
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema#",
+      "id" => "http://json-schema.org/draft-04/hyper-schema#",
+      "allOf" => [
+        { "$ref" => "http://json-schema.org/draft-04/schema#" }
+      ]
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+
+    store = JsonSchema::DocumentStore.new
+    expander = JsonSchema::ReferenceExpander.new
+
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander.expand!(schema2, store: store)
+
+    assert schema1.expanded?
+    assert schema2.expanded?
+  end
+
+  it "it handles oneOf with nested references to a local schema" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "foo" => {
+          "$ref" => "http://json-schema.org/b.json#"
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    schema1.uri = "http://json-schema.org/a.json"
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "definitions" => {
+        "baz" => {
+          "type" => "string",
+          "maxLength" => 3
+        }
+      },
+      "properties" => {
+        "bar" => {
+          "oneOf" => [
+            {"type" => "null"},
+            {"$ref" => "#/definitions/baz"}
+          ]
+        }
+      },
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+    schema2.uri = "http://json-schema.org/b.json"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand(schema1, store: store)
+
+    assert_equal 3, schema1.properties["foo"].properties["bar"].one_of[1].max_length
+  end
+
+  it "expands a schema with a reference to an external schema with a nested local property reference" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "foo" => {
+          "$ref" => "http://json-schema.org/b.json#/definitions/bar"
+        },
+        "foo2" => {
+          "$ref" => "http://json-schema.org/b.json#/definitions/baz"
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    schema1.uri = "http://json-schema.org/a.json"
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "definitions" => {
+        "bar" => {
+          "type" => "object",
+          "properties" => {
+            "omg" => {
+              "$ref" => "#/definitions/baz"
+            }
+          }
+        },
+        "baz" => {
+          "type" => "string",
+          "maxLength" => 3
+        }
+      }
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+    schema2.uri = "http://json-schema.org/b.json"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand!(schema1, store: store)
+
+    # These both point to the same definition, 'baz', but
+    # 'foo' has a level of indirection.
+    assert_equal 3, schema1.properties["foo2"].max_length
+    assert_equal 3, schema1.properties["foo"].properties["omg"].max_length
+  end
+
+  it "expands a reference to a link" do
+    pointer("#/properties").merge!(
+      "link" => { "$ref" => "#/links/0" }
+    )
+    assert expand
+
+    referenced = @schema.links[0]
+    reference = @schema.properties["link"]
+
+    assert_equal reference.href, referenced.href
+  end
+
+  def error_messages
+    @expander.errors.map { |e| e.message }
+  end
+
+  def error_types
+    @expander.errors.map { |e| e.type }
+  end
+
+  def pointer(path)
+    JsonPointer.evaluate(schema_sample, path)
+  end
+
+  def schema_sample
+    @schema_sample ||= DataScaffold.schema_sample
+  end
+
+  def expand(options = {})
+    @schema = JsonSchema::Parser.new.parse!(schema_sample)
+    @expander = JsonSchema::ReferenceExpander.new
+    @expander.expand(@schema, options)
+  end
+end