jsi 0.0.1 → 0.0.2

data/test/jsi_json_hashnode_test.rb

@@ -1,117 +1,131 @@
 require_relative 'test_helper'
 
-describe JSI::JSON::HashNode do
-  # document of the node being tested
-  let(:document) { {'a' => 'b', 'c' => {'d' => 'e'}} }
-  # by default the node is the whole document
-  let(:path) { [] }
-  # the node being tested
-  let(:node) { JSI::JSON::Node.new_by_type(document, path) }
+document_types = [
+  {
+    make_document: -> (d) { d },
+    document: {'a' => 'b', 'c' => {'d' => 'e'}},
+    type_desc: 'Hash',
+  },
+  {
+    make_document: -> (d) { SortOfHash.new(d) },
+    document: SortOfHash.new({'a' => 'b', 'c' => SortOfHash.new({'d' => 'e'})}),
+    type_desc: 'sort of Hash-like',
+  },
+]
+document_types.each do |document_type|
+  describe "JSI::JSON::HashNode with #{document_type[:type_desc]}" do
+    # document of the node being tested
+    let(:document) { document_type[:document] }
+    # by default the node is the whole document
+    let(:path) { [] }
+    # the node being tested
+    let(:node) { JSI::JSON::Node.new_by_type(document, path) }
 
-  describe '#each' do
-    it 'iterates, one argument' do
-      out = []
-      node.each do |arg|
-        out << arg
+    describe '#each' do
+      it 'iterates, one argument' do
+        out = []
+        node.each do |arg|
+          out << arg
+        end
+        assert_instance_of(JSI::JSON::HashNode, node['c'])
+        assert_equal([['a', 'b'], ['c', node['c']]], out)
       end
-      assert_instance_of(JSI::JSON::HashNode, node['c'])
-      assert_equal([['a', 'b'], ['c', node['c']]], out)
-    end
-    it 'iterates, two arguments' do
-      out = []
-      node.each do |k, v|
-        out << [k, v]
+      it 'iterates, two arguments' do
+        out = []
+        node.each do |k, v|
+          out << [k, v]
+        end
+        assert_instance_of(JSI::JSON::HashNode, node['c'])
+        assert_equal([['a', 'b'], ['c', node['c']]], out)
+      end
+      it 'returns self' do
+        assert_equal(node.each { }.object_id, node.object_id)
+      end
+      it 'returns an enumerator when called with no block' do
+        enum = node.each
+        assert_instance_of(Enumerator, enum)
+        assert_equal([['a', 'b'], ['c', node['c']]], enum.to_a)
       end
-      assert_instance_of(JSI::JSON::HashNode, node['c'])
-      assert_equal([['a', 'b'], ['c', node['c']]], out)
     end
-    it 'returns self' do
-      assert_equal(node.each { }.object_id, node.object_id)
+    describe '#to_hash' do
+      it 'returns a Hash with Nodes in' do
+        assert_instance_of(Hash, node.to_hash)
+        assert_equal({'a' => 'b', 'c' => node['c']}, node.to_hash)
+      end
     end
-    it 'returns an enumerator when called with no block' do
-      enum = node.each
-      assert_instance_of(Enumerator, enum)
-      assert_equal([['a', 'b'], ['c', node['c']]], enum.to_a)
+    describe '#merge' do
+      let(:document) { document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}) }
+      # testing the node at 'c' here, merging a hash at a path within a document.
+      let(:path) { ['c'] }
+      it 'merges' do
+        merged = node.merge('x' => 'y')
+        # check the content at 'c' was merged with the remainder of the document intact (at 'a')
+        assert_equal({'a' => {'b' => 0}, 'c' => {'d' => 'e', 'x' => 'y'}}, merged.document)
+        # check the original node retains its original document
+        assert_equal(document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}), node.document)
+        # check that unnecessary copies of unaffected parts of the document were not made
+        assert_equal(node.document.to_hash['a'].object_id, merged.document['a'].object_id)
+      end
     end
-  end
-  describe '#to_hash' do
-    it 'returns a Hash with Nodes in' do
-      assert_instance_of(Hash, node.to_hash)
-      assert_equal({'a' => 'b', 'c' => node['c']}, node.to_hash)
+    describe '#as_json' do
+      let(:document) { document_type[:make_document].call({'a' => 'b'}) }
+      it '#as_json' do
+        assert_equal({'a' => 'b'}, node.as_json)
+        assert_equal({'a' => 'b'}, node.as_json(this_option: 'what?'))
+      end
     end
-  end
-  describe '#merge' do
-    let(:document) { {'a' => {'b' => 0}, 'c' => {'d' => 'e'}} }
-    # testing the node at 'c' here, merging a hash at a path within a document.
-    let(:path) { ['c'] }
-    it 'merges' do
-      merged = node.merge('x' => 'y')
-      # check the content at 'c' was merged with the remainder of the document intact (at 'a')
-      assert_equal({'a' => {'b' => 0}, 'c' => {'d' => 'e', 'x' => 'y'}}, merged.document)
-      # check the original node retains its original document
-      assert_equal({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}, node.document)
-      # check that unnecessary copies of unaffected parts of the document were not made
-      assert_equal(node.document['a'].object_id, merged.document['a'].object_id)
+    # these methods just delegate to Hash so not going to test excessively
+    describe 'key only methods' do
+      it('#each_key') { assert_equal(['a', 'c'], node.each_key.to_a) }
+      it('#empty?')   { assert_equal(false, node.empty?) }
+      it('#has_key?') { assert_equal(true, node.has_key?('a')) }
+      it('#include?') { assert_equal(false, node.include?('q')) }
+      it('#key?')     { assert_equal(true, node.key?('c')) }
+      it('#keys')     { assert_equal(['a', 'c'], node.keys) }
+      it('#length')   { assert_equal(2, node.length) }
+      it('#member?')  { assert_equal(false, node.member?(0)) }
+      it('#size')     { assert_equal(2, node.size) }
     end
-  end
-  describe '#as_json' do
-    let(:document) { {'a' => 'b'} }
-    it '#as_json' do
-      assert_equal({'a' => 'b'}, node.as_json)
-      assert_equal({'a' => 'b'}, node.as_json(this_option: 'what?'))
-    end
-  end
-  # these methods just delegate to Hash so not going to test excessively
-  describe 'key only methods' do
-    it('#each_key') { assert_equal(['a', 'c'], node.each_key.to_a) }
-    it('#empty?')   { assert_equal(false, node.empty?) }
-    it('#has_key?') { assert_equal(true, node.has_key?('a')) }
-    it('#include?') { assert_equal(false, node.include?('q')) }
-    it('#key?')     { assert_equal(true, node.key?('c')) }
-    it('#keys')     { assert_equal(['a', 'c'], node.keys) }
-    it('#length')   { assert_equal(2, node.length) }
-    it('#member?')  { assert_equal(false, node.member?(0)) }
-    it('#size')     { assert_equal(2, node.size) }
-  end
-  describe 'key + value methods' do
-    it('#<')            { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
-    it('#<=')           { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
-    it('#>')            { assert_equal(true, node > {}) } if {}.respond_to?(:>)
-    it('#>=')           { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
-    it('#any?')         { assert_equal(false, node.any? { |k, v| v == 3 }) }
-    it('#assoc')        { assert_equal(['a', 'b'], node.assoc('a')) }
-    it('#dig')          { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
-    it('#each_pair')    { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
-    it('#each_value')   { assert_equal(['b', node['c']], node.each_value.to_a) }
-    it('#fetch')        { assert_equal('b', node.fetch('a')) }
-    it('#fetch_values') { assert_equal(['b'], node.fetch_values('a')) } if {}.respond_to?(:fetch_values)
-    it('#has_value?')   { assert_equal(true, node.has_value?('b')) }
-    it('#invert')       { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
-    it('#key')          { assert_equal('a', node.key('b')) }
-    it('#rassoc')       { assert_equal(['a', 'b'], node.rassoc('b')) }
-    it('#to_h')         { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
-    it('#to_proc')      { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
-    if {}.respond_to?(:transform_values)
-      it('#transform_values') { assert_equal({'a' => nil, 'c' => nil}, node.transform_values { |_| nil}) }
+    describe 'key + value methods' do
+      it('#<')            { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
+      it('#<=')           { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
+      it('#>')            { assert_equal(true, node > {}) } if {}.respond_to?(:>)
+      it('#>=')           { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
+      it('#any?')         { assert_equal(false, node.any? { |k, v| v == 3 }) }
+      it('#assoc')        { assert_equal(['a', 'b'], node.assoc('a')) }
+      it('#dig')          { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
+      it('#each_pair')    { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
+      it('#each_value')   { assert_equal(['b', node['c']], node.each_value.to_a) }
+      it('#fetch')        { assert_equal('b', node.fetch('a')) }
+      it('#fetch_values') { assert_equal(['b'], node.fetch_values('a')) } if {}.respond_to?(:fetch_values)
+      it('#has_value?')   { assert_equal(true, node.has_value?('b')) }
+      it('#invert')       { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
+      it('#key')          { assert_equal('a', node.key('b')) }
+      it('#rassoc')       { assert_equal(['a', 'b'], node.rassoc('b')) }
+      it('#to_h')         { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
+      it('#to_proc')      { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
+      if {}.respond_to?(:transform_values)
+        it('#transform_values') { assert_equal({'a' => nil, 'c' => nil}, node.transform_values { |_| nil }) }
+      end
+      it('#value?')       { assert_equal(false, node.value?('0')) }
+      it('#values')       { assert_equal(['b', node['c']], node.values) }
+      it('#values_at')    { assert_equal(['b'], node.values_at('a')) }
     end
-    it('#value?')       { assert_equal(false, node.value?('0')) }
-    it('#values')       { assert_equal(['b', node['c']], node.values) }
-    it('#values_at')    { assert_equal(['b'], node.values_at('a')) }
-  end
-  describe 'modified copy methods' do
-    # I'm going to rely on the #merge test above to test the modified copy functionality and just do basic
-    # tests of all the modified copy methods here
-    it('#merge')            { assert_equal(node, node.merge({})) }
-    it('#reject')           { assert_equal(JSI::JSON::Node.new_by_type({}, []), node.reject { true }) }
-    it('#select')           { assert_equal(JSI::JSON::Node.new_by_type({}, []), node.select { false }) }
-    # Hash#compact only available as of ruby 2.5.0
-    if {}.respond_to?(:compact)
-      it('#compact')          { assert_equal(node, node.compact) }
+    describe 'modified copy methods' do
+      # I'm going to rely on the #merge test above to test the modified copy functionality and just do basic
+      # tests of all the modified copy methods here
+      it('#merge')            { assert_equal(JSI::JSON::Node.new_doc(node.content.to_hash), node.merge({})) }
+      it('#reject')           { assert_equal(JSI::JSON::Node.new_doc({}), node.reject { true }) }
+      it('#select')           { assert_equal(JSI::JSON::Node.new_doc({}), node.select { false }) }
+      # Hash#compact only available as of ruby 2.5.0
+      if {}.respond_to?(:compact)
+        it('#compact') { assert_equal(JSI::JSON::Node.new_doc({"a" => "b", "c" => node.content.to_hash["c"]}), node.compact) }
+      end
     end
-  end
-  JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-    it("does not respond to destructive method #{destructive_method_name}") do
-      assert(!node.respond_to?(destructive_method_name))
+    JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
+      it("does not respond to destructive method #{destructive_method_name}") do
+        assert(!node.respond_to?(destructive_method_name))
+      end
     end
   end
 end

data/test/jsi_json_node_test.rb

@@ -13,18 +13,18 @@ describe JSI::JSON::Node do
   end
   describe 'initialization by .new_by_type' do
     it 'initializes HashNode' do
-      node = JSI::JSON::Node.new_by_type({'a' => 'b'}, [])
+      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_by_type(['a', 'b'], [])
+      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_by_type(object, [])
+      node = JSI::JSON::Node.new_doc(object)
       assert_instance_of(JSI::JSON::Node, node)
       assert_equal(object, node.document)
     end
@@ -261,22 +261,22 @@ describe JSI::JSON::Node do
       assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new([0], [])])
     end
     it 'hashes consistently regardless of the Node being decorated as a subclass' do
-      assert_equal('x', {JSI::JSON::Node.new_by_type([0], []) => 'x'}[JSI::JSON::Node.new([0], [])])
-      assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new_by_type([0], [])])
+      assert_equal('x', {JSI::JSON::Node.new_doc([0]) => 'x'}[JSI::JSON::Node.new([0], [])])
+      assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new_doc([0])])
     end
     it '==' do
       assert_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new([0], []))
-      assert_equal(JSI::JSON::Node.new_by_type([0], []), JSI::JSON::Node.new([0], []))
-      assert_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new_by_type([0], []))
-      assert_equal(JSI::JSON::Node.new_by_type([0], []), JSI::JSON::Node.new_by_type([0], []))
+      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], []))
+      assert_equal(JSI::JSON::Node.new([0], []), 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], []), JSI::JSON::Node.new({}, []))
-      refute_equal(JSI::JSON::Node.new_by_type([0], []), JSI::JSON::Node.new({}, []))
-      refute_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new_by_type({}, []))
-      refute_equal(JSI::JSON::Node.new_by_type([0], []), JSI::JSON::Node.new_by_type({}, []))
-      refute_equal({}, JSI::JSON::Node.new_by_type({}, []))
-      refute_equal(JSI::JSON::Node.new_by_type({}, []), {})
+      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, []))
+      refute_equal(JSI::JSON::Node.new([0], []), 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

data/test/schema_instance_json_coder_test.rb

@@ -10,7 +10,7 @@ describe JSI::SchemaInstanceJSONCoder do
         assert_nil(schema_instance_json_coder.load(nil))
       end
       it 'loads a hash' do
-        assert_equal(schema_instance_class.new(foo: 'bar'), schema_instance_json_coder.load({"foo" => "bar"}))
+        assert_equal(schema_instance_class.new('foo' => 'bar'), schema_instance_json_coder.load({"foo" => "bar"}))
       end
       it 'loads something else' do
         assert_equal(schema_instance_class.new([[]]), schema_instance_json_coder.load([[]]))
@@ -19,7 +19,7 @@ describe JSI::SchemaInstanceJSONCoder do
         let(:options) { {array: true} }
         it 'loads an array of hashes' do
           data = [{"foo" => "bar"}, {"foo" => "baz"}]
-          assert_equal([schema_instance_class.new(foo: 'bar'), schema_instance_class.new(foo: 'baz')], schema_instance_json_coder.load(data))
+          assert_equal([schema_instance_class.new('foo' => 'bar'), schema_instance_class.new('foo' => 'baz')], schema_instance_json_coder.load(data))
         end
         it 'loads an empty array' do
           assert_equal([], schema_instance_json_coder.load([]))
@@ -36,7 +36,7 @@ describe JSI::SchemaInstanceJSONCoder do
         assert_nil(schema_instance_json_coder.dump(nil))
       end
       it 'dumps a schema_instance_class' do
-        assert_equal({"foo" => "x","bar" => "y"}, schema_instance_json_coder.dump(schema_instance_class.new(foo: 'x', bar: 'y')))
+        assert_equal({"foo" => "x", "bar" => "y"}, schema_instance_json_coder.dump(schema_instance_class.new(foo: 'x', bar: 'y')))
       end
       it 'dumps something else' do
         assert_raises(TypeError) do
@@ -53,7 +53,7 @@ describe JSI::SchemaInstanceJSONCoder do
         let(:options) { {array: true} }
         it 'dumps an array of schema_instances' do
           schema_instances = [schema_instance_class.new(foo: 'x', bar: 'y'), schema_instance_class.new(foo: 'z', bar: 'q')]
-          assert_equal([{"foo" => "x","bar" => "y"},{"foo" => "z","bar" => "q"}], schema_instance_json_coder.dump(schema_instances))
+          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], schema_instance_json_coder.dump(schema_instances))
         end
       end
     end
@@ -65,7 +65,7 @@ describe JSI::SchemaInstanceJSONCoder do
         assert_nil(schema_instance_json_coder.load(nil))
       end
       it 'loads a hash' do
-        assert_equal(schema_instance_class.new(foo: 'bar'), schema_instance_json_coder.load('{"foo": "bar"}'))
+        assert_equal(schema_instance_class.new('foo' => 'bar'), schema_instance_json_coder.load('{"foo": "bar"}'))
       end
       it 'loads something else' do
         assert_equal(schema_instance_class.new([[]]), schema_instance_json_coder.load('[[]]'))
@@ -79,7 +79,7 @@ describe JSI::SchemaInstanceJSONCoder do
         let(:options) { {string: true, array: true} }
         it 'loads an array of hashes' do
           data = '[{"foo": "bar"}, {"foo": "baz"}]'
-          assert_equal([schema_instance_class.new(foo: 'bar'), schema_instance_class.new(foo: 'baz')], schema_instance_json_coder.load(data))
+          assert_equal([schema_instance_class.new('foo' => 'bar'), schema_instance_class.new('foo' => 'baz')], schema_instance_json_coder.load(data))
         end
         it 'loads an empty array' do
           assert_equal([], schema_instance_json_coder.load('[]'))
@@ -118,5 +118,4 @@ describe JSI::SchemaInstanceJSONCoder do
       end
     end
   end
-
 end

data/test/schema_test.rb

@@ -0,0 +1,196 @@
+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.instance, 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' do
+        assert_equal([], schema.fully_validate(instance))
+      end
+      it '#validate' do
+        assert_equal(true, schema.validate(instance))
+      end
+      it '#validate!' do
+        assert_equal(true, schema.validate!(instance))
+      end
+    end
+    describe 'with errors' do
+      let(:instance) { ['no'] }
+      it '#fully_validate' 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))
+      end
+      it '#validate' do
+        assert_equal(false, schema.validate(instance))
+      end
+      it '#validate!' do
+        err = assert_raises(JSON::Schema::ValidationError) do
+          schema.validate!(instance)
+        end
+        assert_equal("The property '#/' of type array did not match the following type: object", err.message)
+      end
+    end
+  end
+end