jsi 0.2.0 → 0.6.0

data/test/jsi_json_node_test.rb

@@ -1,310 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::JSON::Node do
-  let(:path) { [] }
-  let(:pointer) { JSI::JSON::Pointer.new(path) }
-  let(:node) { JSI::JSON::Node.new(document, pointer) }
-
-  describe 'initialization' do
-    it 'initializes' do
-      node = JSI::JSON::Node.new({'a' => 'b'}, pointer)
-      assert_equal({'a' => 'b'}, node.document)
-      assert_equal(JSI::JSON::Pointer.new([]), node.pointer)
-    end
-    it 'initializes, pointer is not pointer' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new({'a' => 'b'}, []) }
-      assert_equal('pointer must be a JSI::JSON::Pointer. got: [] (Array)', err.message)
-    end
-    it 'initializes, document is another Node' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(JSI::JSON::Node.new({'a' => 'b'}, pointer), pointer) }
-      assert_equal("document of a Node should not be another JSI::JSON::Node: #<JSI::JSON::Node fragment=\"#\" {\"a\"=>\"b\"}>", err.message)
-    end
-  end
-  describe 'initialization by .new_by_type' do
-    it 'initializes HashNode' do
-      node = JSI::JSON::Node.new_doc({'a' => 'b'})
-      assert_instance_of(JSI::JSON::HashNode, node)
-      assert_equal({'a' => 'b'}, node.document)
-    end
-    it 'initializes ArrayNode' do
-      node = JSI::JSON::Node.new_doc(['a', 'b'])
-      assert_instance_of(JSI::JSON::ArrayNode, node)
-      assert_equal(['a', 'b'], node.document)
-    end
-    it 'initializes Node' do
-      object = Object.new
-      node = JSI::JSON::Node.new_doc(object)
-      assert_instance_of(JSI::JSON::Node, node)
-      assert_equal(object, node.document)
-    end
-  end
-  describe '#pointer' do
-    it 'is a JSI::JSON::Pointer' do
-      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, pointer).pointer)
-    end
-  end
-  describe '#path' do
-    it 'is an array of reference tokens' do
-      assert_equal(['a'], JSI::JSON::Node.new({}, JSI::JSON::Pointer.new(['a'])).path)
-    end
-  end
-  describe '#content' do
-    it 'returns the content at the root' do
-      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, pointer).content)
-    end
-    it 'returns the content from the deep' do
-      assert_equal('b', JSI::JSON::Node.new([0, {'x' => [{'a' => ['b']}]}], JSI::JSON::Pointer.new([1, 'x', 0, 'a', 0])).content)
-    end
-  end
-  describe '#deref' do
-    let(:document) do
-      {
-        'foo' => {'bar' => ['baz']},
-        'a' => {'$ref' => '#/foo'},
-      }
-    end
-    it 'follows a $ref' do
-      assert_equal({'bar' => ['baz']}, node['a'].deref.content)
-    end
-    it 'returns the node when there is no $ref to follow' do
-      assert_equal({'bar' => ['baz']}, node['foo'].deref.content)
-    end
-    describe "dealing with google's invalid $refs" do
-      let(:document) do
-        {
-          'schemas' => {'bar' => {'description' => ['baz']}},
-          'a' => {'$ref' => 'bar', 'foo' => 'bar'},
-        }
-      end
-      it 'subscripts a node consisting of a $ref WITHOUT following' do
-        subscripted = node['a']
-        assert_equal({'$ref' => 'bar', 'foo' => 'bar'}, subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new(['a']), subscripted.pointer)
-      end
-      it 'looks for a node in #/schemas with the name of the $ref' do
-        assert_equal({'description' => ['baz']}, node['a'].deref.content)
-      end
-      it 'follows a $ref when subscripting past it' do
-        subscripted = node['a']['description']
-        assert_equal(['baz'], subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new(['schemas', 'bar', 'description']), subscripted.pointer)
-      end
-      it 'does not follow a $ref when subscripting a key that is present' do
-        subscripted = node['a']['foo']
-        assert_equal('bar', subscripted)
-      end
-    end
-    describe "dealing with whatever this is" do
-      # I think google uses this style in some cases maybe. I don't remember.
-      let(:document) do
-        {
-          'schemas' => {'bar' => {'id' => 'BarID', 'description' => 'baz'}},
-          'a' => {'$ref' => 'BarID'},
-        }
-      end
-      it 'looks for a node in #/schemas with the name of the $ref' do
-        assert_equal({'id' => 'BarID', 'description' => 'baz'}, node['a'].deref.content)
-      end
-    end
-  end
-  describe '#[]' do
-    describe 'without dereferencing' do
-      let(:document) { [0, {'x' => [{'a' => ['b']}]}] }
-      it 'subscripts arrays and hashes' do
-        assert_equal('b', node[1]['x'][0]['a'][0])
-      end
-      it 'returns ArrayNode for an array' do
-        subscripted = node[1]['x']
-        assert_instance_of(JSI::JSON::ArrayNode, subscripted)
-        assert_equal([{'a' => ['b']}], subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new([1, 'x']), subscripted.pointer)
-      end
-      it 'returns HashNode for a Hash' do
-        subscripted = node[1]
-        assert_instance_of(JSI::JSON::HashNode, subscripted)
-        assert_equal({'x' => [{'a' => ['b']}]}, subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new([1]), subscripted.pointer)
-      end
-      describe 'content does not respond to []' do
-        let(:document) { Object.new }
-        it 'cannot subscript' do
-          err = assert_raises(NoMethodError) { node['x'] }
-          assert_equal("undefined method `[]`\nsubscripting with \"x\" (String) from Object. content is: #{document.pretty_inspect.chomp}", err.message)
-        end
-      end
-    end
-    describe 'with dereferencing' do
-      let(:document) do
-        {
-          'foo' => {'bar' => ['baz']},
-          'a' => {'$ref' => '#/foo', 'description' => 'hi'}, # not sure a description is actually allowed here, whatever
-        }
-      end
-      it 'subscripts a node consisting of a $ref WITHOUT following' do
-        subscripted = node['a']
-        assert_equal({'$ref' => '#/foo', 'description' => 'hi'}, subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new(['a']), subscripted.pointer)
-      end
-      it 'follows a $ref when subscripting past it' do
-        subscripted = node['a']['bar']
-        assert_equal(['baz'], subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new(['foo', 'bar']), subscripted.pointer)
-      end
-      it 'does not follow a $ref when subscripting a key that is present' do
-        subscripted = node['a']['description']
-        assert_equal('hi', subscripted)
-      end
-    end
-  end
-  describe '#[]=' do
-    let(:document) { [0, {'x' => [{'a' => ['b']}]}] }
-    it 'assigns' do
-      node[0] = 'abcdefg'
-      assert_equal(['abcdefg', {'x' => [{'a' => ['b']}]}], document)
-      string_node = JSI::JSON::Node.new(document, JSI::JSON::Pointer.new([0]))
-      string_node[0..2] = '0'
-      assert_equal(['0defg', {'x' => [{'a' => ['b']}]}], document)
-      node[0] = node[1]
-      assert_equal([{'x' => [{'a' => ['b']}]}, {'x' => [{'a' => ['b']}]}], document)
-    end
-    it 'assigns, deeper' do
-      node[1]['y'] = node[1]['x'][0]
-      assert_equal([0, {'x' => [{'a' => ['b']}], 'y' => {'a' => ['b']}}], document)
-    end
-  end
-  describe '#document_node' do
-    let(:document) { {'a' => {'b' => 3}} }
-    it 'has content that is the document' do
-      assert_equal({'a' => {'b' => 3}}, node['a'].document_node.content)
-    end
-  end
-  describe '#parent_node' do
-    let(:document) { {'a' => {'b' => []}} }
-    it 'finds a parent' do
-      sub = node['a']['b']
-      assert_equal(JSI::JSON::Pointer.new(['a', 'b']), sub.pointer)
-      parent = sub.parent_node
-      assert_equal(JSI::JSON::Pointer.new(['a']), parent.pointer)
-      assert_equal({'b' => []}, parent.content)
-      assert_equal(node['a'], parent)
-      root_from_sub = sub.parent_node.parent_node
-      assert_equal(JSI::JSON::Pointer.new([]), root_from_sub.pointer)
-      assert_equal({'a' => {'b' => []}}, root_from_sub.content)
-      assert_equal(node, root_from_sub)
-      err = assert_raises(JSI::JSON::Pointer::ReferenceError) do
-        root_from_sub.parent_node
-      end
-      assert_match(/\Acannot access parent of root pointer: #<JSI::JSON::Pointer/, err.message)
-    end
-  end
-  describe '#pointer_path' do
-    let(:document) { {'a' => {'b' => 3}} }
-    it 'is empty' do
-      assert_equal('', node.pointer_path)
-    end
-    it 'is not empty' do
-      assert_equal('/a', node['a'].pointer_path)
-    end
-    describe 'containing an empty string and some slashes and tildes that need escaping' do
-      let(:document) { {'' => {'a/b~c!d#e[f]' => []}} }
-      it 'matches' do
-        assert_equal('//a~1b~0c!d#e[f]', node['']['a/b~c!d#e[f]'].pointer_path)
-      end
-    end
-  end
-  describe '#fragment' do
-    let(:document) { {'a' => {'b' => 3}} }
-    it 'is empty' do
-      assert_equal('#', node.fragment)
-    end
-    it 'is not empty' do
-      assert_equal('#/a', node['a'].fragment)
-    end
-    describe 'containing an empty string and some slashes and tildes that need escaping' do
-      let(:document) { {'' => {'a/b~c!d#e[f]' => []}} }
-      it 'matches' do
-        assert_equal('#//a~1b~0c!d#e%5Bf%5D', node['']['a/b~c!d#e[f]'].fragment)
-      end
-    end
-  end
-  describe '#modified_copy' do
-    let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
-    let(:path) { ['1', 'c'] }
-    it 'returns a different object' do
-      # simplest thing
-      modified_dup = node.modified_copy(&:dup)
-      # it is equal - being a dup
-      assert_equal(modified_dup, node)
-      # but different object
-      refute_equal(node.object_id, modified_dup.object_id)
-      # the parents, obviously, are different
-      refute_equal(node.parent_node.content.object_id, modified_dup.parent_node.content.object_id)
-      refute_equal(node.parent_node.parent_node.content.object_id, modified_dup.parent_node.parent_node.content.object_id)
-      # but any untouched part(s) - in this case the ['b', 'q'] at document[0] - are untouched
-      assert_equal(node.document_node[0].content.object_id, modified_dup.document_node[0].content.object_id)
-    end
-    it 'returns the same object' do
-      unmodified_dup = node.modified_copy { |o| o }
-      assert_equal(unmodified_dup, node)
-      # same object, since the block just returned it
-      refute_equal(node.object_id, unmodified_dup.object_id)
-      # the parents are unchanged since the object is the same
-      assert_equal(node.parent_node.content.object_id, unmodified_dup.parent_node.content.object_id)
-      assert_equal(node.parent_node.parent_node.content.object_id, unmodified_dup.parent_node.parent_node.content.object_id)
-      # same as the other: any untouched part(s) - in this case the ['b', 'q'] at document[0] - are untouched
-      assert_equal(node.document_node[0].content.object_id, unmodified_dup.document_node[0].content.object_id)
-    end
-    it 'raises subscripting string from array' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, JSI::JSON::Pointer.new(['x'])).modified_copy(&:dup) }
-      assert_match(%r(\Abad subscript "x" with remaining subpath: \[\] for array: \[.*\]\z)m, err.message)
-    end
-    it 'raises subscripting from invalid subpath' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, JSI::JSON::Pointer.new([0, 0, 'what'])).modified_copy(&:dup) }
-      assert_match(%r(bad subscript: "what" with remaining subpath: \[\] for content: "b"\z)m, err.message)
-    end
-  end
-  describe '#inspect' do
-    let(:document) { {'a' => {'c' => ['d', 'e']}} }
-    let(:path) { ['a'] }
-    it 'inspects' do
-      assert_equal(%Q(#<JSI::JSON::Node fragment="#/a" {"c"=>["d", "e"]}>), node.inspect)
-    end
-  end
-  describe '#pretty_print' do
-    let(:document) { {'a' => {'c' => ['d', 'e']}} }
-    let(:path) { ['a'] }
-    it 'pretty prints' do
-      assert_equal(%Q(#<JSI::JSON::Node fragment="#/a" {"c"=>["d", "e"]}>), node.pretty_inspect.chomp)
-    end
-  end
-  describe '#fingerprint' do
-    let(:pointer) { JSI::JSON::Pointer.new([]) }
-    it 'hashes consistently' do
-      assert_equal('x', {JSI::JSON::Node.new([0], pointer) => 'x'}[JSI::JSON::Node.new([0], pointer)])
-    end
-    it 'hashes consistently regardless of the Node being decorated as a subclass' do
-      assert_equal('x', {JSI::JSON::Node.new_doc([0]) => 'x'}[JSI::JSON::Node.new([0], pointer)])
-      assert_equal('x', {JSI::JSON::Node.new([0], pointer) => 'x'}[JSI::JSON::Node.new_doc([0])])
-    end
-    it '==' do
-      assert_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new([0], pointer))
-      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], pointer))
-      assert_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new_doc([0]))
-      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new_doc([0]))
-    end
-    it '!=' do
-      refute_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new({}, pointer))
-      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, pointer))
-      refute_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new_doc({}))
-      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new_doc({}))
-      refute_equal({}, JSI::JSON::Node.new_doc({}))
-      refute_equal(JSI::JSON::Node.new_doc({}), {})
-    end
-  end
-  describe '#as_json' do
-    let(:document) { {'a' => 'b'} }
-    it '#as_json' do
-      assert_equal({'a' => 'b'}, node.as_json)
-    end
-  end
-end

data/test/jsi_json_pointer_test.rb

@@ -1,106 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::JSON::Pointer do
-  # For example, given the document
-  let(:document) do
-    {
-       "foo" => ["bar", "baz"],
-       "" => 0,
-       "a/b" => 1,
-       "c%d" => 2,
-       "e^f" => 3,
-       "g|h" => 4,
-       "i\\j" => 5,
-       "k\"l" => 6,
-       " " => 7,
-       "m~n" => 8,
-    }
-  end
-
-  describe 'initialize from pointer' do
-    it 'parses' do
-      # The following strings evaluate to the accompanying values:
-      evaluations = [
-        ""      ,     document,
-        "/foo"  ,     ["bar", "baz"],
-        "/foo/0",     "bar",
-        "/"     ,     0,
-        "/a~1b" ,     1,
-        "/c%d"  ,     2,
-        "/e^f"  ,     3,
-        "/g|h"  ,     4,
-        "/i\\j" ,     5,
-        "/k\"l" ,     6,
-        "/ "    ,     7,
-        "/m~0n" ,     8,
-      ]
-      evaluations.each_slice(2) do |pointer, value|
-        assert_equal(value, JSI::JSON::Pointer.from_pointer(pointer).evaluate(document))
-      end
-    end
-
-    it 'raises for invalid syntax' do
-      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.from_pointer("this does not begin with slash").evaluate(document)
-      end
-      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
-    end
-  end
-  describe 'initialize from fragment' do
-    # For example, given the document
-    let(:document) do
-      {
-         "foo" => ["bar", "baz"],
-         "" => 0,
-         "a/b" => 1,
-         "c%d" => 2,
-         "e^f" => 3,
-         "g|h" => 4,
-         "i\\j" => 5,
-         "k\"l" => 6,
-         " " => 7,
-         "m~n" => 8,
-      }
-    end
-
-    it 'parses' do
-      # the following URI fragment identifiers evaluate to the accompanying values:
-      evaluations = [
-        '#',            document,
-        '#/foo',        ["bar", "baz"],
-        '#/foo/0',      "bar",
-        '#/',           0,
-        '#/a~1b',       1,
-        '#/c%25d',      2,
-        '#/e%5Ef',      3,
-        '#/g%7Ch',      4,
-        '#/i%5Cj',      5,
-        '#/k%22l',      6,
-        '#/%20',        7,
-        '#/m~0n',       8,
-      ]
-      evaluations.each_slice(2) do |fragment, value|
-        assert_equal(value, JSI::JSON::Pointer.from_fragment(fragment).evaluate(document))
-      end
-    end
-
-    it 'raises for invalid syntax' do
-      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.from_fragment("this does not begin with #").evaluate(document)
-      end
-      assert_equal("Invalid fragment syntax in \"this does not begin with #\": fragment must begin with #", err.message)
-      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.from_fragment("#this does not begin with slash").evaluate(document)
-      end
-      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
-    end
-  end
-  describe 'initialize' do
-    describe 'invalid reference_tokens' do
-      it 'raises' do
-        err = assert_raises(TypeError) { JSI::JSON::Pointer.new({}) }
-        assert_equal("reference_tokens must be an array. got: {}", err.message)
-      end
-    end
-  end
-end

data/test/jsi_test.rb

@@ -1,11 +0,0 @@
-require_relative 'test_helper'
-
-class JSITest < Minitest::Test
-  def test_that_it_has_a_version_number
-    refute_nil ::JSI::VERSION
-  end
-
-  def test_it_does_something_useful
-    assert true
-  end
-end

data/test/jsi_typelike_as_json_test.rb

@@ -1,53 +0,0 @@
-require_relative 'test_helper'
-
-class JSONifiable
-  def initialize(object)
-    @object = object
-  end
-  def as_json
-    @object
-  end
-end
-
-describe JSI::Typelike do
-  describe 'as_json' do
-    it 'expresses as json' do
-      assert_equal({}, JSI::Typelike.as_json({}))
-      assert_equal([], JSI::Typelike.as_json([]))
-
-      # symbols to string
-      assert_equal(['a'], JSI::Typelike.as_json([:a]))
-
-      # set
-      assert_equal(['a'], JSI::Typelike.as_json(Set.new(['a'])))
-
-      # responds to #to_hash / #to_ary but naught else
-      assert_equal({'a' => 'b'}, JSI::Typelike.as_json(SortOfHash.new({'a' => 'b'})))
-      assert_equal(['a'], JSI::Typelike.as_json(SortOfArray.new(['a'])))
-
-      # symbol keys to string
-      assert_equal({'a' => 'b'}, JSI::Typelike.as_json({a: 'b'}))
-      # non string/symbol key
-      err = assert_raises(TypeError) { JSI::Typelike.as_json({nil => 0}) }
-      assert_equal('json object (hash) cannot be keyed with: nil', err.message)
-
-      # schema
-      schema = JSI::Schema.from_object({'type' => 'array'})
-      assert_equal({'type' => 'array'}, JSI::Typelike.as_json(schema))
-
-      # JSI
-      assert_equal(['a'], JSI::Typelike.as_json(JSI.class_for_schema(schema).new(['a'])))
-
-      # JSON::Node
-      assert_equal(['a'], JSI::Typelike.as_json(JSI::JSON::Node.new_doc(['a'])))
-
-      # #as_json
-      assert_equal(['a'], JSI::Typelike.as_json(JSONifiable.new(['a'])))
-
-      # not jsonifiable
-      object = Object.new
-      err = assert_raises(TypeError) { JSI::Typelike.as_json(object) }
-      assert_equal("cannot express object as json: #{object.pretty_inspect.chomp}", err.message)
-    end
-  end
-end

data/test/schema_test.rb

@@ -1,196 +0,0 @@
-require_relative 'test_helper'
-
-SomeMetaschema = JSI.class_for_schema({id: 'https://schemas.jsi.unth.net/test/somemetaschema', type: 'object'})
-
-describe JSI::Schema do
-  describe 'new' do
-    it 'initializes from a hash' do
-      schema = JSI::Schema.new({'type' => 'object'})
-      assert_equal(JSI::JSON::Node.new_doc({'type' => 'object'}), schema.schema_node)
-    end
-    it 'initializes from a Node' do
-      schema_node = JSI::JSON::Node.new_doc({'type' => 'object'})
-      schema = JSI::Schema.new(schema_node)
-      assert_equal(schema_node, schema.schema_node)
-      assert_equal(schema_node, schema.schema_object)
-    end
-    it 'initializes from a JSI' do
-      schema_jsi = SomeMetaschema.new('type' => 'object')
-      schema = JSI::Schema.new(schema_jsi)
-      assert_equal(schema_jsi, schema.schema_node)
-      assert_equal(schema_jsi, schema.schema_object)
-    end
-    it 'cannot instantiate from some unknown object' do
-      err = assert_raises(TypeError) { JSI::Schema.new(Object.new) }
-      assert_match(/\Acannot instantiate Schema from: #<Object:.*>\z/m, err.message)
-    end
-    it 'makes no sense to instantiate schema from schema' do
-      err = assert_raises(TypeError) { JSI::Schema.new(JSI::Schema.new({})) }
-      assert_match(/\Awill not instantiate Schema from another Schema: #<JSI::Schema schema_id=.*>\z/m, err.message)
-    end
-  end
-  describe 'as an instance of metaschema' do
-    let(:default_metaschema) do
-      validator = ::JSON::Validator.default_validator
-      metaschema_file = validator.metaschema
-      JSI::Schema.new(::JSON.parse(File.read(metaschema_file)))
-    end
-    let(:metaschema_jsi_class) { JSI.class_for_schema(default_metaschema) }
-    let(:schema_object) { {'type' => 'array', 'items' => {'description' => 'items!'}} }
-    let(:schema_jsi) { metaschema_jsi_class.new(schema_object) }
-    let(:schema) { JSI::Schema.new(schema_jsi) }
-    it '#[]' do
-      schema_items = schema['items']
-      assert_instance_of(metaschema_jsi_class, schema_items)
-      assert_equal({'description' => 'items!'}, schema_items.as_json)
-    end
-  end
-  describe '#schema_id' do
-    it 'generates one' do
-      assert_match(/\A[0-9a-f\-]+#\z/, JSI::Schema.new({}).schema_id)
-    end
-    it 'uses a given id with a fragment' do
-      schema = JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/given_id#'})
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#', schema.schema_id)
-    end
-    it 'uses a given id (adding a fragment)' do
-      schema = JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/given_id'})
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#', schema.schema_id)
-    end
-    it 'uses a pointer in the fragment' do
-      schema_node = JSI::JSON::Node.new_doc({
-        'id' => 'https://schemas.jsi.unth.net/test/given_id#',
-        'properties' => {'foo' => {'type' => 'object'}},
-      })
-      schema = JSI::Schema.new(schema_node['properties']['foo'])
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#/properties/foo', schema.schema_id)
-    end
-    it 'uses a pointer in the fragment relative to the fragment of the root' do
-      schema_node = JSI::JSON::Node.new_doc({
-        'id' => 'https://schemas.jsi.unth.net/test/given_id#/notroot',
-        'properties' => {'foo' => {'type' => 'object'}},
-      })
-      schema = JSI::Schema.new(schema_node['properties']['foo'])
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#/notroot/properties/foo', schema.schema_id)
-    end
-  end
-  describe '#schema_class' do
-    it 'returns the class for the schema' do
-      schema_node = JSI::JSON::Node.new_doc({'id' => 'https://schemas.jsi.unth.net/test/schema_schema_class'})
-      assert_equal(JSI.class_for_schema(schema_node), JSI::Schema.new(schema_node).schema_class)
-    end
-  end
-  describe '#subschema_for_property' do
-    let(:schema) do
-      JSI::Schema.new({
-        properties: {foo: {description: 'foo'}},
-        patternProperties: {"^ba" => {description: 'ba*'}},
-        additionalProperties: {description: 'whatever'},
-      })
-    end
-    it 'has no subschema' do
-      assert_equal(nil, JSI::Schema.new({}).subschema_for_property('no'))
-    end
-    it 'has a subschema by property' do
-      subschema = schema.subschema_for_property('foo')
-      assert_instance_of(JSI::Schema, subschema)
-      assert_equal('foo', subschema['description'])
-    end
-    it 'has a subschema by pattern property' do
-      subschema = schema.subschema_for_property('bar')
-      assert_instance_of(JSI::Schema, subschema)
-      assert_equal('ba*', subschema['description'])
-    end
-    it 'has a subschema by additional properties' do
-      subschema = schema.subschema_for_property('anything')
-      assert_instance_of(JSI::Schema, subschema)
-      assert_equal('whatever', subschema['description'])
-    end
-  end
-  describe '#subschema_for_index' do
-    it 'has no subschema' do
-      assert_equal(nil, JSI::Schema.new({}).subschema_for_index(0))
-    end
-    it 'has a subschema for items' do
-      schema = JSI::Schema.new({
-        items: {description: 'items!'}
-      })
-      first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
-      assert_equal('items!', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
-      assert_equal('items!', last_subschema['description'])
-    end
-    it 'has a subschema for each item by index' do
-      schema = JSI::Schema.new({
-        items: [{description: 'item one'}, {description: 'item two'}]
-      })
-      first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
-      assert_equal('item one', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
-      assert_equal('item two', last_subschema['description'])
-    end
-    it 'has a subschema by additional items' do
-      schema = JSI::Schema.new({
-        items: [{description: 'item one'}],
-        additionalItems: {description: "mo' crap"},
-      })
-      first_subschema = schema.subschema_for_index(0)
-      assert_instance_of(JSI::Schema, first_subschema)
-      assert_equal('item one', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_instance_of(JSI::Schema, last_subschema)
-      assert_equal("mo' crap", last_subschema['description'])
-    end
-  end
-  describe 'stringification' do
-    let(:schema) do
-      JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/stringification', type: 'object'})
-    end
-
-    it '#inspect' do
-      assert_equal(%q(#<JSI::Schema schema_id=https://schemas.jsi.unth.net/test/stringification# #{<JSI::JSON::HashNode fragment="#"> "id" => "https://schemas.jsi.unth.net/test/stringification", "type" => "object"}>), schema.inspect)
-    end
-    it '#pretty_print' do
-      assert_equal(%q(#<JSI::Schema schema_id=https://schemas.jsi.unth.net/test/stringification#
-        #{<JSI::JSON::HashNode fragment="#">
-          "id" => "https://schemas.jsi.unth.net/test/stringification",
-          "type" => "object"
-        }
-      >).gsub(/^      /, ''), schema.pretty_inspect.chomp)
-    end
-  end
-  describe 'validation' do
-    let(:schema) { JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/validation', type: 'object'}) }
-    describe 'without errors' do
-      let(:instance) { {'foo' => 'bar'} }
-      it '#fully_validate_instance' do
-        assert_equal([], schema.fully_validate_instance(instance))
-      end
-      it '#validate_instance' do
-        assert_equal(true, schema.validate_instance(instance))
-      end
-      it '#validate_instance!' do
-        assert_equal(true, schema.validate_instance!(instance))
-      end
-    end
-    describe 'with errors' do
-      let(:instance) { ['no'] }
-      it '#fully_validate_instance' do
-        assert_equal(["The property '#/' of type array did not match the following type: object in schema https://schemas.jsi.unth.net/test/validation"], schema.fully_validate_instance(instance))
-      end
-      it '#validate_instance' do
-        assert_equal(false, schema.validate_instance(instance))
-      end
-      it '#validate_instance!' do
-        err = assert_raises(JSON::Schema::ValidationError) do
-          schema.validate_instance!(instance)
-        end
-        assert_equal("The property '#/' of type array did not match the following type: object", err.message)
-      end
-    end
-  end
-end