jsi 0.0.1

data/test/jsi_json_arraynode_test.rb

@@ -0,0 +1,133 @@
+require_relative 'test_helper'
+
+describe JSI::JSON::ArrayNode do
+  # document of the node being tested
+  let(:document) { ['a', ['b', 'q'], {'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) }
+
+  describe '#[] bad index' do
+    it 'improves TypeError for Array subsript' do
+      err = assert_raises(TypeError) do
+        node[:x]
+      end
+      assert_match(/^subscripting with :x \(Symbol\) from Array. self is: #\[<JSI::JSON::ArrayNode fragment="#">/, err.message)
+    end
+  end
+  describe '#each' do
+    it 'iterates, one argument' do
+      out = []
+      node.each do |arg|
+        out << arg
+      end
+      assert_instance_of(JSI::JSON::ArrayNode, node[1])
+      assert_instance_of(JSI::JSON::HashNode, node[2])
+      assert_equal(['a', node[1], node[2]], 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', node[1], node[2]], enum.to_a)
+    end
+  end
+  describe '#to_ary' do
+    it 'returns a Array with Nodes in' do
+      assert_instance_of(Array, node.to_ary)
+      assert_equal(['a', node[1], node[2]], node.to_ary)
+    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(some_option: false))
+    end
+  end
+  # these methods just delegate to Array so not going to test excessively
+  describe 'index only methods' do
+    it('#each_index') { assert_equal([0, 1, 2], node.each_index.to_a) }
+    it('#empty?')     { assert_equal(false, node.empty?) }
+    it('#length')     { assert_equal(3, node.length) }
+    it('#size')       { assert_equal(3, node.size) }
+  end
+  describe 'index + element methods' do
+    it('#|')                    { assert_equal(['a', node[1], node[2], 0], node | [0]) }
+    it('#&')                    { assert_equal(['a'], node & ['a']) }
+    it('#*')                    { assert_equal(node.to_a, node * 1) }
+    it('#+')                    { assert_equal(node.to_a, node + []) }
+    it('#-')                    { assert_equal([node[1], node[2]], node - ['a']) }
+    it('#<=>')                  { assert_equal(1, node <=> []) }
+    it('#<=>')                  { assert_equal(-1, [] <=> node) }
+    require 'abbrev'
+    it('#abbrev')               { assert_equal({'a' => 'a'}, JSI::JSON::Node.new_by_type(['a'], []).abbrev) }
+    it('#assoc')                { assert_equal(['b', 'q'], node.assoc('b')) }
+    it('#at')                   { assert_equal('a', node.at(0)) }
+    it('#bsearch')              { assert_equal(nil, node.bsearch { false }) }
+    it('#bsearch_index')        { assert_equal(nil, node.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
+    it('#combination')          { assert_equal([['a'], [node[1]], [node[2]]], node.combination(1).to_a) }
+    it('#count')                { assert_equal(1, node.count('a')) }
+    it('#cycle')                { assert_equal(node.to_a, node.cycle(1).to_a) }
+    it('#dig')                  { assert_equal('e', node.dig(2, 'c', 'd')) } if [].respond_to?(:dig)
+    it('#drop')                 { assert_equal([node[2]], node.drop(2)) }
+    it('#drop_while')           { assert_equal([node[1], node[2]], node.drop_while { |e| e == 'a' }) }
+    it('#fetch')                { assert_equal('a', node.fetch(0)) }
+    it('#find_index')           { assert_equal(0, node.find_index { true }) }
+    it('#first')                { assert_equal('a', node.first) }
+    it('#include?')             { assert_equal(true, node.include?('a')) }
+    it('#index')                { assert_equal(0, node.index('a')) }
+    it('#join')                 { assert_equal('a b', JSI::JSON::Node.new_by_type(['a', 'b'], []).join(' ')) }
+    it('#last')                 { assert_equal(node[2], node.last) }
+    it('#pack')                 { assert_equal(' ', JSI::JSON::Node.new_by_type([32], []).pack('c')) }
+    it('#permutation')          { assert_equal([['a'], [node[1]], [node[2]]], node.permutation(1).to_a) }
+    it('#product')              { assert_equal([], node.product([])) }
+    # due to differences in implementation between #assoc and #rassoc, the reason for which
+    # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
+    # type checking than assoc for the array(like) array elements.
+    # compare:
+    # assoc:  https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3780-L3813
+    # rassoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3815-L3847
+    # for this reason, rassoc is NOT defined on Arraylike and #content must be called.
+    it('#rassoc')               { assert_equal(['b', 'q'], node.content.rassoc('q')) }
+    it('#repeated_combination') { assert_equal([[]], node.repeated_combination(0).to_a) }
+    it('#repeated_permutation') { assert_equal([[]], node.repeated_permutation(0).to_a) }
+    it('#reverse')              { assert_equal([node[2], node[1], 'a'], node.reverse) }
+    it('#reverse_each')         { assert_equal([node[2], node[1], 'a'], node.reverse_each.to_a) }
+    it('#rindex')               { assert_equal(0, node.rindex('a')) }
+    it('#rotate')               { assert_equal([node[1], node[2], 'a'], node.rotate) }
+    it('#sample')               { assert_equal('a', JSI::JSON::Node.new_by_type(['a'], []).sample) }
+    it('#shelljoin')            { assert_equal('a', JSI::JSON::Node.new_by_type(['a'], []).shelljoin) } if [].respond_to?(:shelljoin)
+    it('#shuffle')              { assert_equal(3, node.shuffle.size) }
+    it('#slice')                { assert_equal(['a'], node.slice(0, 1)) }
+    it('#sort')                 { assert_equal(['a'], JSI::JSON::Node.new_by_type(['a'], []).sort) }
+    it('#take')                 { assert_equal(['a'], node.take(1)) }
+    it('#take_while')           { assert_equal([], node.take_while { false }) }
+    it('#transpose')            { assert_equal([], JSI::JSON::Node.new_by_type([], []).transpose) }
+    it('#uniq')                 { assert_equal(node.to_a, node.uniq) }
+    it('#values_at')            { assert_equal(['a'], node.values_at(0)) }
+    it('#zip')                  { assert_equal([['a', 'a'], [node[1], node[1]], [node[2], node[2]]], node.zip(node)) }
+  end
+  describe 'modified copy methods' do
+    it('#reject')  { assert_equal(JSI::JSON::Node.new_by_type(['a'], []), node.reject { |e| e != 'a' }) }
+    it('#select')  { assert_equal(JSI::JSON::Node.new_by_type(['a'], []), node.select { |e| e == 'a' }) }
+    it('#compact') { assert_equal(node, node.compact) }
+    describe 'at a depth' do
+      let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
+      let(:path) { ['1', 'c'] }
+      it('#select') do
+        selected = node.select { |e| e == 'd' }
+        equivalent = JSI::JSON::Node.new_by_type([['b', 'q'], {'c' => ['d']}], ['1', 'c'])
+        assert_equal(equivalent, selected)
+      end
+    end
+  end
+  JSI::Arraylike::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

data/test/jsi_json_hashnode_test.rb

@@ -0,0 +1,117 @@
+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) }
+
+  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
+    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
+  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)
+    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)
+    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}) }
+    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) }
+    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))
+    end
+  end
+end

data/test/jsi_json_node_test.rb

@@ -0,0 +1,288 @@
+require_relative 'test_helper'
+
+describe JSI::JSON::Node do
+  let(:path) { [] }
+  let(:node) { JSI::JSON::Node.new(document, path) }
+
+  describe 'initialization' do
+    it 'initializes' do
+      node = JSI::JSON::Node.new({'a' => 'b'}, [])
+      assert_equal({'a' => 'b'}, node.document)
+      assert_equal([], node.path)
+    end
+  end
+  describe 'initialization by .new_by_type' do
+    it 'initializes HashNode' do
+      node = JSI::JSON::Node.new_by_type({'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'], [])
+      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, [])
+      assert_instance_of(JSI::JSON::Node, node)
+      assert_equal(object, node.document)
+    end
+  end
+  describe '#pointer' do
+    it 'is a ::JSON::Schema::Pointer' do
+      assert_instance_of(::JSON::Schema::Pointer, JSI::JSON::Node.new({}, []).pointer)
+    end
+  end
+  describe '#content' do
+    it 'returns the content at the root' do
+      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, []).content)
+    end
+    it 'returns the content from the deep' do
+      assert_equal('b', JSI::JSON::Node.new([0, {'x' => [{'a' => ['b']}]}], [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(['a'], subscripted.path)
+      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(['schemas', 'bar', 'description'], subscripted.path)
+      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([1, 'x'], subscripted.path)
+      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([1], subscripted.path)
+      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(['a'], subscripted.path)
+      end
+      it 'follows a $ref when subscripting past it' do
+        subscripted = node['a']['bar']
+        assert_equal(['baz'], subscripted.content)
+        assert_equal(['foo', 'bar'], subscripted.path)
+      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, [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(['a', 'b'], sub.path)
+      parent = sub.parent_node
+      assert_equal(['a'], parent.path)
+      assert_equal({'b' => []}, parent.content)
+      assert_equal(node['a'], parent)
+      root_from_sub = sub.parent_node.parent_node
+      assert_equal([], root_from_sub.path)
+      assert_equal({'a' => {'b' => []}}, root_from_sub.content)
+      assert_equal(node, root_from_sub)
+      err = assert_raises(::JSON::Schema::Pointer::ReferenceError) do
+        root_from_sub.parent_node
+      end
+      assert_match(/\Acannot access parent of root node: #\{<JSI::JSON::HashNode/, 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, ['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, [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
+    it 'hashes consistently' 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], [])])
+    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], []))
+    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({}, []), {})
+    end
+  end
+  describe '#as_json' do
+    let(:document) { {'a' => 'b'} }
+    it '#as_json' do
+      assert_equal({'a' => 'b'}, node.as_json)
+    end
+  end
+end