jsi 0.0.1

data/lib/jsi/util.rb

@@ -0,0 +1,103 @@
+module JSI
+  module Util
+    def stringify_symbol_keys(hash)
+      unless hash.respond_to?(:to_hash)
+        raise(ArgumentError, "expected argument to be a hash; got #{hash.class.inspect}: #{hash.pretty_inspect.chomp}")
+      end
+      JSI::Typelike.modified_copy(hash) do |hash_|
+        changed = false
+        out = {}
+        hash_.each do |k, v|
+          if k.is_a?(Symbol)
+            changed = true
+            k = k.to_s
+          end
+          out[k] = v
+        end
+        changed ? out : hash_
+      end
+    end
+
+    def deep_stringify_symbol_keys(object)
+      if object.respond_to?(:to_hash)
+        JSI::Typelike.modified_copy(object) do |hash|
+          changed = false
+          out = {}
+          hash.each do |k, v|
+            if k.is_a?(Symbol)
+              changed = true
+              k = k.to_s
+            end
+            out_k = deep_stringify_symbol_keys(k)
+            out_v = deep_stringify_symbol_keys(v)
+            changed = true if out_k.object_id != k.object_id
+            changed = true if out_v.object_id != v.object_id
+            out[out_k] = out_v
+          end
+          changed ? out : hash
+        end
+      elsif object.respond_to?(:to_ary)
+        JSI::Typelike.modified_copy(object) do |ary|
+          changed = false
+          out = ary.map do |e|
+            out_e = deep_stringify_symbol_keys(e)
+            changed = true if out_e.object_id != e.object_id
+            out_e
+          end
+          changed ? out : ary
+        end
+      else
+        object
+      end
+    end
+  end
+  extend Util
+
+  module FingerprintHash
+    def ==(other)
+      object_id == other.object_id || (other.respond_to?(:fingerprint) && other.fingerprint == self.fingerprint)
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      fingerprint.hash
+    end
+  end
+
+  module Memoize
+    def memoize(key, *args_)
+      @memos ||= {}
+      @memos[key] ||= Hash.new do |h, args|
+        h[args] = yield(*args)
+      end
+      @memos[key][args_]
+    end
+
+    def clear_memo(key, *args)
+      @memos ||= {}
+      if @memos[key]
+        if args.empty?
+          @memos[key].clear
+        else
+          @memos[key].delete(args)
+        end
+      end
+    end
+  end
+  extend Memoize
+
+  # this is the Y-combinator, which allows anonymous recursive functions. for a simple example, 
+  # to define a recursive function to return the length of an array:
+  #
+  #  length = ycomb do |len|
+  #    proc{|list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
+  #  end
+  #
+  # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
+  # and chapter 9 of the little schemer, available as the sample chapter at http://www.ccs.neu.edu/home/matthias/BTLS/
+  def ycomb
+    proc { |f| f.call(f) }.call(proc { |f| yield proc{|*x| f.call(f).call(*x) } })
+  end
+  module_function :ycomb
+end

data/lib/jsi/version.rb

@@ -0,0 +1,3 @@
+module JSI
+  VERSION = "0.0.1"
+end

data/test/base_array_test.rb

@@ -0,0 +1,142 @@
+require_relative 'test_helper'
+
+describe JSI::BaseArray do
+  let(:document) do
+    ['foo', {'lamp' => [3]}, ['q', 'r']]
+  end
+  let(:path) { [] }
+  let(:instance) { JSI::JSON::Node.new_by_type(document, path) }
+  let(:schema_content) do
+    {
+      'type' => 'array',
+      'items' => [
+        {'type' => 'string'},
+        {'type' => 'object', 'items' => {}},
+        {'type' => 'array'},
+      ],
+    }
+  end
+  let(:schema) { JSI::Schema.new(schema_content) }
+  let(:class_for_schema) { JSI.class_for_schema(schema) }
+  let(:subject) { class_for_schema.new(instance) }
+
+  describe 'arraylike []=' do
+    it 'sets an index' do
+      orig_2 = subject[2]
+
+      subject[2] = {'y' => 'z'}
+
+      assert_equal({'y' => 'z'}, subject[2].as_json)
+      assert_instance_of(JSI.class_for_schema(schema.schema_node['items'][2]), orig_2)
+      assert_instance_of(JSI.class_for_schema(schema.schema_node['items'][2]), subject[2])
+    end
+    it 'modifies the instance, visible to other references to the same instance' do
+      orig_instance = subject.instance
+
+      subject[2] = {'y' => 'z'}
+
+      assert_equal(orig_instance, subject.instance)
+      assert_equal({'y' => 'z'}, orig_instance[2].as_json)
+      assert_equal({'y' => 'z'}, subject.instance[2].as_json)
+      assert_equal(orig_instance.class, subject.instance.class)
+    end
+    describe 'when the instance is not arraylike' do
+      let(:instance) { nil }
+      it 'errors' do
+        err = assert_raises(NoMethodError) { subject[2] = 0 }
+        assert_match(%r(\Aundefined method `\[\]=' for #<JSI::SchemaClasses::X.*>\z), err.message)
+      end
+    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], subject.each_index.to_a) }
+    it('#empty?')     { assert_equal(false, subject.empty?) }
+    it('#length')     { assert_equal(3, subject.length) }
+    it('#size')       { assert_equal(3, subject.size) }
+  end
+  describe 'index + element methods' do
+    it('#|')                    { assert_equal(['foo', subject[1], subject[2], 0], subject | [0]) }
+    it('#&')                    { assert_equal(['foo'], subject & ['foo']) }
+    it('#*')                    { assert_equal(subject.to_a, subject * 1) }
+    it('#+')                    { assert_equal(subject.to_a, subject + []) }
+    it('#-')                    { assert_equal([subject[1], subject[2]], subject - ['foo']) }
+    it('#<=>')                  { assert_equal(1, subject <=> []) }
+    it('#<=>')                  { assert_equal(-1, [] <=> subject) }
+    require 'abbrev'
+    it('#abbrev')               { assert_equal({'a' => 'a'}, class_for_schema.new(['a']).abbrev) }
+    it('#assoc')                { assert_equal(['q', 'r'], subject.instance.assoc('q')) }
+    it('#at')                   { assert_equal('foo', subject.at(0)) }
+    it('#bsearch')              { assert_equal(nil, subject.bsearch { false }) }
+    it('#bsearch_index')        { assert_equal(nil, subject.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
+    it('#combination')          { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.combination(1).to_a) }
+    it('#count')                { assert_equal(1, subject.count('foo')) }
+    it('#cycle')                { assert_equal(subject.to_a, subject.cycle(1).to_a) }
+    it('#dig')                  { assert_equal(3, subject.dig(1, 'lamp', 0)) } if [].respond_to?(:dig)
+    it('#drop')                 { assert_equal([subject[2]], subject.drop(2)) }
+    it('#drop_while')           { assert_equal([subject[1], subject[2]], subject.drop_while { |e| e == 'foo' }) }
+    it('#fetch')                { assert_equal('foo', subject.fetch(0)) }
+    it('#find_index')           { assert_equal(0, subject.find_index { true }) }
+    it('#first')                { assert_equal('foo', subject.first) }
+    it('#include?')             { assert_equal(true, subject.include?('foo')) }
+    it('#index')                { assert_equal(0, subject.index('foo')) }
+    it('#join')                 { assert_equal('a b', class_for_schema.new(['a', 'b']).join(' ')) }
+    it('#last')                 { assert_equal(subject[2], subject.last) }
+    it('#pack')                 { assert_equal(' ', class_for_schema.new([32]).pack('c')) }
+    it('#permutation')          { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.permutation(1).to_a) }
+    it('#product')              { assert_equal([], subject.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(['q', 'r'], subject.instance.content.rassoc('r')) }
+    it('#repeated_combination') { assert_equal([[]], subject.repeated_combination(0).to_a) }
+    it('#repeated_permutation') { assert_equal([[]], subject.repeated_permutation(0).to_a) }
+    it('#reverse')              { assert_equal([subject[2], subject[1], 'foo'], subject.reverse) }
+    it('#reverse_each')         { assert_equal([subject[2], subject[1], 'foo'], subject.reverse_each.to_a) }
+    it('#rindex')               { assert_equal(0, subject.rindex('foo')) }
+    it('#rotate')               { assert_equal([subject[1], subject[2], 'foo'], subject.rotate) }
+    it('#sample')               { assert_equal('a', class_for_schema.new(['a']).sample) }
+    it('#shelljoin')            { assert_equal('a', class_for_schema.new(['a']).shelljoin) } if [].respond_to?(:shelljoin)
+    it('#shuffle')              { assert_equal(3, subject.shuffle.size) }
+    it('#slice')                { assert_equal(['foo'], subject.slice(0, 1)) }
+    it('#sort')                 { assert_equal(['a'], class_for_schema.new(['a']).sort) }
+    it('#take')                 { assert_equal(['foo'], subject.take(1)) }
+    it('#take_while')           { assert_equal([], subject.take_while { false }) }
+    it('#transpose')            { assert_equal([], class_for_schema.new([]).transpose) }
+    it('#uniq')                 { assert_equal(subject.to_a, subject.uniq) }
+    it('#values_at')            { assert_equal(['foo'], subject.values_at(0)) }
+    it('#zip')                  { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]]], subject.zip(subject)) }
+  end
+  describe 'modified copy methods' do
+    it('#reject')  { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], [])), subject.reject { |e| e != 'foo' }) }
+    it('#reject block var') do
+      subj_a = subject.to_a
+      subject.reject { |e| assert_equal(e, subj_a.shift) }
+    end
+    it('#select')  { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], [])), subject.select { |e| e == 'foo' }) }
+    it('#select block var') do
+      subj_a = subject.to_a
+      subject.select { |e| assert_equal(e, subj_a.shift) }
+    end
+    it('#compact') { assert_equal(subject, subject.compact) }
+    describe 'at a depth' do
+      let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
+      let(:path) { ['1', 'c'] }
+      it('#select') do
+        selected = subject.select { |e| e == 'd' }
+        equivalent_node = JSI::JSON::ArrayNode.new([['b', 'q'], {'c' => ['d']}], path)
+        equivalent = class_for_schema.new(equivalent_node)
+        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(!subject.respond_to?(destructive_method_name))
+    end
+  end
+end

data/test/base_hash_test.rb

@@ -0,0 +1,135 @@
+require_relative 'test_helper'
+
+describe JSI::BaseHash do
+  let(:document) do
+    {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}
+  end
+  let(:path) { [] }
+  let(:instance) { JSI::JSON::Node.new_by_type(document, path) }
+  let(:schema_content) do
+    {
+      'type' => 'object',
+      'properties' => {
+        'foo' => {'type' => 'object'},
+        'bar' => {},
+      },
+    }
+  end
+  let(:schema) { JSI::Schema.new(schema_content) }
+  let(:class_for_schema) { JSI.class_for_schema(schema) }
+  let(:subject) { class_for_schema.new(instance) }
+
+  describe 'hashlike []=' do
+    it 'sets a property' do
+      orig_foo = subject['foo']
+
+      subject['foo'] = {'y' => 'z'}
+
+      assert_equal({'y' => 'z'}, subject['foo'].as_json)
+      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), orig_foo)
+      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
+    end
+    it 'sets a property to a schema instance with a different schema' do
+      orig_foo = subject['foo']
+
+      subject['foo'] = subject['bar']
+
+      # the content of the subscripts' instances is the same but the subscripts' classes are different
+      assert_equal([9], subject['foo'].as_json)
+      assert_equal([9], subject['bar'].as_json)
+      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
+      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['bar']), subject['bar'])
+    end
+    it 'sets a property to a schema instance with the same schema' do
+      other_subject = class_for_schema.new(JSI::JSON::Node.new_by_type({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}, []))
+      # Given
+      assert_equal(other_subject, subject)
+
+      # When:
+      subject['foo'] = other_subject['foo']
+
+      # Then:
+      # still equal
+      assert_equal(other_subject, subject)
+      # but different instances
+      refute_equal(other_subject['foo'].object_id, subject['foo'].object_id)
+    end
+    it 'modifies the instance, visible to other references to the same instance' do
+      orig_instance = subject.instance
+
+      subject['foo'] = {'y' => 'z'}
+
+      assert_equal(orig_instance, subject.instance)
+      assert_equal({'y' => 'z'}, orig_instance['foo'].as_json)
+      assert_equal({'y' => 'z'}, subject.instance['foo'].as_json)
+      assert_equal(orig_instance.class, subject.instance.class)
+    end
+    describe 'when the instance is not hashlike' do
+      let(:instance) { nil }
+      it 'errors' do
+        err = assert_raises(NoMethodError) { subject['foo'] = 0 }
+        assert_match(%r(\Aundefined method `\[\]=' for #<JSI::SchemaClasses::.*>\z), err.message)
+      end
+    end
+  end
+  # these methods just delegate to Hash so not going to test excessively
+  describe 'key only methods' do
+    it('#each_key') { assert_equal(['foo', 'bar', 'baz'], subject.each_key.to_a) }
+    it('#empty?')   { assert_equal(false, subject.empty?) }
+    it('#has_key?') { assert_equal(true, subject.has_key?('bar')) }
+    it('#include?') { assert_equal(false, subject.include?('q')) }
+    it('#key?')     { assert_equal(true, subject.key?('baz')) }
+    it('#keys')     { assert_equal(['foo', 'bar', 'baz'], subject.keys) }
+    it('#length')   { assert_equal(3, subject.length) }
+    it('#member?')  { assert_equal(false, subject.member?(0)) }
+    it('#size')     { assert_equal(3, subject.size) }
+  end
+  describe 'key + value methods' do
+    it('#<')            { assert_equal(true, subject < {'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true, 'x' => 'y'}) } if {}.respond_to?(:<)
+    it('#<=')           { assert_equal(true, subject <= subject) } if {}.respond_to?(:<=)
+    it('#>')            { assert_equal(true, subject > {}) } if {}.respond_to?(:>)
+    it('#>=')           { assert_equal(false, subject >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
+    it('#any?')         { assert_equal(false, subject.any? { |k, v| v == 3 }) }
+    it('#assoc')        { assert_equal(['foo', subject['foo']], subject.assoc('foo')) }
+    it('#dig')          { assert_equal(9, subject.dig('bar', 0)) } if {}.respond_to?(:dig)
+    it('#each_pair')    { assert_equal([['foo', subject['foo']], ['bar', subject['bar']], ['baz', true]], subject.each_pair.to_a) }
+    it('#each_value')   { assert_equal([subject['foo'], subject['bar'], true], subject.each_value.to_a) }
+    it('#fetch')        { assert_equal(true, subject.fetch('baz')) }
+    it('#fetch_values') { assert_equal([true], subject.fetch_values('baz')) } if {}.respond_to?(:fetch_values)
+    it('#has_value?')   { assert_equal(true, subject.has_value?(true)) }
+    it('#invert')       { assert_equal({subject['foo'] => 'foo', subject['bar'] => 'bar', true => 'baz'}, subject.invert) }
+    it('#key')          { assert_equal('baz', subject.key(true)) }
+    it('#rassoc')       { assert_equal(['baz', true], subject.rassoc(true)) }
+    it('#to_h')         { assert_equal({'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true}, subject.to_h) }
+    it('#to_proc')      { assert_equal(true, subject.to_proc.call('baz')) } if {}.respond_to?(:to_proc)
+    if {}.respond_to?(:transform_values)
+      it('#transform_values') { assert_equal({'foo' => nil, 'bar' => nil, 'baz' => nil}, subject.transform_values { |_| nil}) }
+    end
+    it('#value?')       { assert_equal(false, subject.value?('0')) }
+    it('#values')       { assert_equal([subject['foo'], subject['bar'], true], subject.values) }
+    it('#values_at')    { assert_equal([true], subject.values_at('baz')) }
+  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(subject, subject.merge({})) }
+    it('#reject')           { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, [])), subject.reject { true }) }
+    it('#select')           { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, [])), subject.select { false }) }
+    describe '#select' do
+      it 'yields properly too' do
+        subject.select do |k, v|
+          assert_equal(subject[k], v)
+        end
+      end
+    end
+    # Hash#compact only available as of ruby 2.5.0
+    if {}.respond_to?(:compact)
+      it('#compact')        { assert_equal(subject, subject.compact) }
+    end
+  end
+  JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
+    it("does not respond to destructive method #{destructive_method_name}") do
+      assert(!subject.respond_to?(destructive_method_name))
+    end
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,395 @@
+require_relative 'test_helper'
+
+NamedSchemaInstance = JSI.class_for_schema({id: 'https://schemas.jsi.unth.net/test/base/named_schema'})
+
+describe JSI::Base do
+  let(:document) { {} }
+  let(:path) { [] }
+  let(:instance) { JSI::JSON::Node.new_by_type(document, path) }
+  let(:schema_content) { {} }
+  let(:schema) { JSI::Schema.new(schema_content) }
+  let(:subject) { JSI.class_for_schema(schema).new(instance) }
+  describe 'class .inspect + .to_s' do
+    it 'is the same as Class#inspect on the base' do
+      assert_equal('JSI::Base', JSI::Base.inspect)
+      assert_equal('JSI::Base', JSI::Base.to_s)
+    end
+    it 'is SchemaClasses[] for generated subclass without id' do
+      assert_match(%r(\AJSI::SchemaClasses\["[a-f0-9\-]+#"\]\z), subject.class.inspect)
+      assert_match(%r(\AJSI::SchemaClasses\["[a-f0-9\-]+#"\]\z), subject.class.to_s)
+    end
+    describe 'with schema id' do
+      let(:schema_content) { {'id' => 'https://jsi/foo'} }
+      it 'is SchemaClasses[] for generated subclass with id' do
+        assert_equal(%q(JSI::SchemaClasses["https://jsi/foo#"]), subject.class.inspect)
+        assert_equal(%q(JSI::SchemaClasses["https://jsi/foo#"]), subject.class.to_s)
+      end
+    end
+    it 'is the constant name (plus id for .inspect) for a class assigned to a constant' do
+      assert_equal(%q(NamedSchemaInstance (https://schemas.jsi.unth.net/test/base/named_schema#)), NamedSchemaInstance.inspect)
+      assert_equal(%q(NamedSchemaInstance), NamedSchemaInstance.to_s)
+    end
+  end
+  describe 'class name' do
+    let(:schema_content) { {'id' => 'https://jsi/BaseTest'} }
+    it 'generates a class name from schema_id' do
+      assert_equal('JSI::SchemaClasses::Https___jsi_BaseTest_', subject.class.name)
+    end
+    it 'uses an existing name' do
+      assert_equal('NamedSchemaInstance', NamedSchemaInstance.name)
+    end
+  end
+  describe 'class for schema .schema' do
+    it '.schema' do
+      assert_equal(schema, JSI.class_for_schema(schema).schema)
+    end
+  end
+  describe 'class for schema .schema_id' do
+    it '.schema_id' do
+      assert_equal(schema.schema_id, JSI.class_for_schema(schema).schema_id)
+    end
+  end
+  describe 'module for schema .inspect' do
+    it '.inspect' do
+      assert_match(%r(\A#<Module for Schema: .+#>\z), JSI.module_for_schema(schema).inspect)
+    end
+  end
+  describe 'module for schema .schema' do
+    it '.schema' do
+      assert_equal(schema, JSI.module_for_schema(schema).schema)
+    end
+  end
+  describe 'SchemaClasses[]' do
+    it 'stores the class for the schema' do
+      assert_equal(JSI.class_for_schema(schema), JSI::SchemaClasses[schema.schema_id])
+    end
+  end
+  describe '.class_for_schema' do
+    it 'returns a class from a schema' do
+      class_for_schema = JSI.class_for_schema(schema)
+      # same class every time
+      assert_equal(JSI.class_for_schema(schema), class_for_schema)
+      assert_operator(class_for_schema, :<, JSI::Base)
+    end
+    it 'returns a class from a hash' do
+      assert_equal(JSI.class_for_schema(schema), JSI.class_for_schema(schema.schema_node.content))
+    end
+    it 'returns a class from a schema node' do
+      assert_equal(JSI.class_for_schema(schema), JSI.class_for_schema(schema.schema_node))
+    end
+    it 'returns a class from a Base' do
+      assert_equal(JSI.class_for_schema(schema), JSI.class_for_schema(JSI.class_for_schema({}).new(schema.schema_node)))
+    end
+  end
+  describe '.module_for_schema' do
+    it 'returns a module from a schema' do
+      module_for_schema = JSI.module_for_schema(schema)
+      # same module every time
+      assert_equal(JSI.module_for_schema(schema), module_for_schema)
+    end
+    it 'returns a module from a hash' do
+      assert_equal(JSI.module_for_schema(schema), JSI.module_for_schema(schema.schema_node.content))
+    end
+    it 'returns a module from a schema node' do
+      assert_equal(JSI.module_for_schema(schema), JSI.module_for_schema(schema.schema_node))
+    end
+    it 'returns a module from a Base' do
+      assert_equal(JSI.module_for_schema(schema), JSI.module_for_schema(JSI.class_for_schema({}).new(schema.schema_node)))
+    end
+  end
+  describe 'initialization' do
+    describe 'on Base' do
+      it 'errors' do
+        err = assert_raises(TypeError) { JSI::Base.new({}) }
+        assert_equal('cannot instantiate JSI::Base which has no method #schema. please use JSI.class_for_schema', err.message)
+      end
+    end
+    describe 'nil' do
+      let(:instance) { nil }
+      it 'initializes with nil instance' do
+        assert_equal(JSI::JSON::Node.new_by_type(nil, []), subject.instance)
+        assert(!subject.respond_to?(:to_ary))
+        assert(!subject.respond_to?(:to_hash))
+      end
+    end
+    describe 'arbitrary instance' do
+      let(:instance) { Object.new }
+      it 'initializes' do
+        assert_equal(JSI::JSON::Node.new_by_type(instance, []), subject.instance)
+        assert(!subject.respond_to?(:to_ary))
+        assert(!subject.respond_to?(:to_hash))
+      end
+    end
+    describe 'hash' do
+      let(:instance) { {'foo' => 'bar'} }
+      let(:schema_content) { {'type' => 'object'} }
+      it 'initializes' do
+        assert_equal(JSI::JSON::Node.new_by_type({'foo' => 'bar'}, []), subject.instance)
+        assert(!subject.respond_to?(:to_ary))
+        assert(subject.respond_to?(:to_hash))
+      end
+    end
+    describe 'JSI::JSON::Hashnode' do
+      let(:document) { {'foo' => 'bar'} }
+      let(:schema_content) { {'type' => 'object'} }
+      it 'initializes' do
+        assert_equal(JSI::JSON::HashNode.new({'foo' => 'bar'}, []), subject.instance)
+        assert(!subject.respond_to?(:to_ary))
+        assert(subject.respond_to?(:to_hash))
+      end
+    end
+    describe 'array' do
+      let(:instance) { ['foo'] }
+      let(:schema_content) { {'type' => 'array'} }
+      it 'initializes' do
+        assert_equal(JSI::JSON::Node.new_by_type(['foo'], []), subject.instance)
+        assert(subject.respond_to?(:to_ary))
+        assert(!subject.respond_to?(:to_hash))
+      end
+    end
+    describe 'JSI::JSON::Arraynode' do
+      let(:document) { ['foo'] }
+      let(:schema_content) { {'type' => 'array'} }
+      it 'initializes' do
+        assert_equal(JSI::JSON::ArrayNode.new(['foo'], []), subject.instance)
+        assert(subject.respond_to?(:to_ary))
+        assert(!subject.respond_to?(:to_hash))
+      end
+    end
+    describe 'another Base' do
+      let(:schema_content) { {'type' => 'object'} }
+      let(:instance) { JSI.class_for_schema(schema).new({'foo' => 'bar'}) }
+      it 'initializes with a warning' do
+        assert_output(nil, /assigning instance to a Base instance is incorrect. received: #\{<JSI::SchemaClasses\["[^"]+#"\][^>]*>[^}]+}/) do
+          subject
+        end
+        assert_equal(JSI::JSON::HashNode.new({'foo' => 'bar'}, []), subject.instance)
+      end
+    end
+  end
+  describe '#parents, #parent' do
+    let(:schema_content) { {properties: {foo: {properties: {bar: {properties: {baz: {}}}}}}} }
+    let(:document) { {foo: {bar: {baz: {}}}} }
+    describe 'no parents' do
+      it 'has none' do
+        assert_equal([], subject.parents)
+        assert_equal(nil, subject.parent)
+      end
+    end
+    describe 'one parent' do
+      it 'has one' do
+        assert_equal([subject], subject.foo.parents)
+        assert_equal(subject, subject.foo.parent)
+      end
+    end
+    describe 'more parents' do
+      it 'has more' do
+        assert_equal([subject.foo.bar, subject.foo, subject], subject.foo.bar.baz.parents)
+        assert_equal(subject.foo.bar, subject.foo.bar.baz.parent)
+      end
+    end
+  end
+  describe '#each, Enumerable methods' do
+    let(:document) { 'a string' }
+    it "raises NoMethodError calling each or Enumerable methods" do
+      assert_raises(NoMethodError) { subject.each { nil } }
+      assert_raises(NoMethodError) { subject.map { nil } }
+    end
+  end
+  describe '#modified_copy' do
+    describe 'with an instance that does have #modified_copy' do
+      it 'yields the instance to modify' do
+        modified = subject.modified_copy do |o|
+          assert_equal({}, o)
+          {'a' => 'b'}
+        end
+        assert_equal({'a' => 'b'}, modified.instance.content)
+        assert_equal({}, subject.instance.content)
+        refute_equal(instance, modified)
+      end
+    end
+    describe 'no modification' do
+      it 'yields the instance to modify' do
+        modified = subject.modified_copy { |o| o }
+        # this doesn't really need to be tested but ... whatever
+        assert_equal(subject.instance.content.object_id, modified.instance.content.object_id)
+        assert_equal(subject, modified)
+        refute_equal(subject.object_id, modified.object_id)
+      end
+    end
+    describe 'resulting in a different type' do
+      let(:schema_content) { {'type' => 'object'} }
+      it 'works' do
+        # I'm not really sure the best thing to do here, but this is how it is for now. this is subject to change.
+        modified = subject.modified_copy do |o|
+          o.to_s
+        end
+        assert_equal('{}', modified.instance.content)
+        assert_equal({}, subject.instance.content)
+        refute_equal(instance, modified)
+        # interesting side effect
+        assert(subject.respond_to?(:to_hash))
+        assert(!modified.respond_to?(:to_hash))
+        assert_equal(JSI::JSON::HashNode, subject.instance.class)
+        assert_equal(JSI::JSON::Node, modified.instance.class)
+      end
+    end
+  end
+  it('#fragment') { assert_equal('#', subject.fragment) }
+  describe 'validation' do
+    describe 'without errors' do
+      it '#fully_validate' do
+        assert_equal([], subject.fully_validate)
+      end
+      it '#validate' do
+        assert_equal(true, subject.validate)
+      end
+      it '#validate!' do
+        assert_equal(true, subject.validate!)
+      end
+    end
+  end
+  describe 'property accessors' do
+    let(:schema_content) do
+      {
+        'type' => 'object',
+        'properties' => {
+          'foo' => {'type' => 'object'},
+          'bar' => {'type' => 'array'},
+          'baz' => {},
+        },
+      }
+    end
+    let(:document) do
+      {'foo' => {'x' => 'y'}, 'bar' => [3.14159], 'baz' => true, 'qux' => []}
+    end
+    describe 'readers' do
+      it 'reads attributes described as properties' do
+        assert_equal({'x' => 'y'}, subject.foo.as_json)
+        assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject.foo)
+        assert_respond_to(subject.foo, :to_hash)
+        refute_respond_to(subject.foo, :to_ary)
+        assert_equal([3.14159], subject.bar.as_json)
+        assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['bar']), subject.bar)
+        refute_respond_to(subject.bar, :to_hash)
+        assert_respond_to(subject.bar, :to_ary)
+        assert_equal(true, subject.baz)
+        refute_respond_to(subject.baz, :to_hash)
+        refute_respond_to(subject.baz, :to_ary)
+        refute_respond_to(subject, :qux)
+      end
+      describe 'when the instance is not hashlike' do
+        let(:instance) { nil }
+        it 'errors' do
+          err = assert_raises(NoMethodError) { subject.foo }
+          assert_match(%r(\Ainstance does not respond to \[\]; cannot call reader `foo' for: #<JSI::SchemaClasses\["[^"]+#"\].*nil.*>\z)m, err.message)
+        end
+      end
+      describe 'properties with the same names as instance methods' do
+        let(:schema_content) do
+          {
+            'type' => 'object',
+            'properties' => {
+              'foo' => {},            # not an instance method
+              'initialize' => {},     # Base
+              'inspect' => {},        # Base
+              'pretty_inspect' => {}, # Kernel
+              'as_json' => {},        # Base::OverrideFromExtensions, extended on initialization
+              'each' => {},           # BaseHash / BaseArray
+              'instance_exec' => {},  # BasicObject
+              'instance' => {},       # Base
+              'schema' => {},         # module_for_schema singleton definition
+            },
+          }
+        end
+        let(:document) do
+          {
+            'foo' => 'bar',
+            'initialize' => 'hi',
+            'inspect' => 'hi',
+            'pretty_inspect' => 'hi',
+            'as_json' => 'hi',
+            'each' => 'hi',
+            'instance_exec' => 'hi',
+            'instance' => 'hi',
+            'schema' => 'hi',
+          }
+        end
+        it 'does not define readers' do
+          assert_equal('bar', subject.foo)
+          assert_equal(JSI.module_for_schema(subject.schema), subject.method(:foo).owner)
+
+          assert_equal(JSI::Base, subject.method(:initialize).owner)
+          assert_equal('hi', subject['initialize'])
+          assert_match(%r(\A#\{<JSI::SchemaClasses\[".*#"\].*}\z)m, subject.inspect)
+          assert_equal('hi', subject['inspect'])
+          assert_match(%r(\A#\{<JSI::SchemaClasses\[".*#"\].*}\Z)m, subject.pretty_inspect)
+          assert_equal(document, subject.as_json)
+          assert_equal(subject, subject.each { })
+          assert_equal(2, subject.instance_exec { 2 })
+          assert_equal(instance, subject.instance)
+          assert_equal(schema, subject.schema)
+        end
+      end
+    end
+    describe 'writers' do
+      it 'writes attributes described as properties' do
+        orig_foo = subject.foo
+
+        subject.foo = {'y' => 'z'}
+
+        assert_equal({'y' => 'z'}, subject.foo.as_json)
+        assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), orig_foo)
+        assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject.foo)
+      end
+      it 'modifies the instance, visible to other references to the same instance' do
+        orig_instance = subject.instance
+
+        subject.foo = {'y' => 'z'}
+
+        assert_equal(orig_instance, subject.instance)
+        assert_equal({'y' => 'z'}, orig_instance['foo'].as_json)
+        assert_equal({'y' => 'z'}, subject.instance['foo'].as_json)
+        assert_equal(orig_instance.class, subject.instance.class)
+      end
+      describe 'when the instance is not hashlike' do
+        let(:instance) { nil }
+        it 'errors' do
+          err = assert_raises(NoMethodError) { subject.foo = 0 }
+          assert_match(%r(\Ainstance does not respond to \[\]=; cannot call writer `foo=' for: #<JSI::SchemaClasses\["[^"]+#"\].*nil.*>\z)m, err.message)
+        end
+      end
+    end
+  end
+  describe '#inspect' do
+    # if the instance is hash-like, #inspect gets overridden
+    let(:document) { Object.new }
+    it 'inspects' do
+      assert_match(%r(\A#<JSI::SchemaClasses\["[^"]+#"\] #<JSI::JSON::Node fragment="#" #<Object:[^<>]*>>>\z), subject.inspect)
+    end
+  end
+  describe '#pretty_print' do
+    # if the instance is hash-like, #pretty_print gets overridden
+    let(:document) { Object.new }
+    it 'pretty_prints' do
+      assert_match(%r(\A#<JSI::SchemaClasses\["[^"]+#"\]\n  #<JSI::JSON::Node fragment="#" #<Object:[^<>]*>>\n>\z), subject.pretty_inspect.chomp)
+    end
+  end
+  describe '#as_json' do
+    it '#as_json' do
+      assert_equal({'a' => 'b'}, JSI.class_for_schema({}).new(JSI::JSON::Node.new_by_type({'a' => 'b'}, [])).as_json)
+      assert_equal({'a' => 'b'}, JSI.class_for_schema({'type' => 'object'}).new(JSI::JSON::Node.new_by_type({'a' => 'b'}, [])).as_json)
+      assert_equal(['a', 'b'], JSI.class_for_schema({'type' => 'array'}).new(JSI::JSON::Node.new_by_type(['a', 'b'], [])).as_json)
+      assert_equal(['a'], JSI::class_for_schema({}).new(['a']).as_json(some_option: true))
+    end
+  end
+  describe 'overwrite schema instance with instance=' do
+    # this error message indicates an internal bug (hence Bug class), so there isn't an intended way to
+    # trigger it using JSI::Base properly. we use it improperly just to test that code path. this
+    # is definitely not defined behavior.
+    it 'errors' do
+      err = assert_raises(JSI::Bug) { subject.send(:instance=, {'foo' => 'bar'}) }
+      assert_match(%r(\Aoverwriting instance is not supported\z), err.message)
+    end
+  end
+end