jsi 0.4.0 → 0.6.0

data/test/base_array_test.rb

@@ -1,323 +0,0 @@
-require_relative 'test_helper'
-
-base = {
-  'description' => 'named array schema',
-  'type' => 'array',
-  'items' => [
-    {'type' => 'string'},
-    {'type' => 'object'},
-    {'type' => 'array', 'items' => {}},
-  ],
-}
-NamedArrayInstance = JSI::Schema.new(base).jsi_schema_class
-NamedIdArrayInstance = JSI::Schema.new({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base)).jsi_schema_class
-
-describe 'JSI::Base array' do
-  let(:instance) { ['foo', {'lamp' => [3]}, ['q', 'r'], {'four' => 4}] }
-  let(:schema_content) do
-    {
-      'description' => 'hash schema',
-      'type' => 'array',
-      'items' => [
-        {'type' => 'string'},
-        {'type' => 'object'},
-        {'type' => 'array', 'items' => {}},
-      ],
-    }
-  end
-  let(:schema) { JSI::Schema.new(schema_content) }
-  let(:subject) { schema.new_jsi(instance) }
-
-  describe '#[] with a default that is a basic type' do
-    let(:schema_content) do
-      {
-        'type' => 'array',
-        'items' => {'default' => 'foo'},
-      }
-    end
-    describe 'default value' do
-      let(:instance) { [1] }
-      it 'returns the default value' do
-        assert_equal('foo', subject[2])
-      end
-    end
-    describe 'nondefault value (basic type)' do
-      let(:instance) { ['who'] }
-      it 'returns the nondefault value' do
-        assert_equal('who', subject[0])
-      end
-    end
-    describe 'nondefault value (nonbasic type)' do
-      let(:instance) { [[2]] }
-      it 'returns the nondefault value' do
-        assert_is_a(schema.items.jsi_schema_module, subject[0])
-        assert_equal([2], subject[0].as_json)
-      end
-    end
-  end
-  describe '#[] with a default that is a nonbasic type' do
-    let(:schema_content) do
-      {
-        'type' => 'array',
-        'items' => {'default' => {'foo' => 2}},
-      }
-    end
-    describe 'default value' do
-      let(:instance) { [{'bar' => 3}] }
-      it 'returns the default value' do
-        assert_is_a(schema.items.jsi_schema_module, subject[1])
-        assert_equal({'foo' => 2}, subject[1].as_json)
-      end
-    end
-    describe 'nondefault value (basic type)' do
-      let(:instance) { [true, 'who'] }
-      it 'returns the nondefault value' do
-        assert_equal('who', subject[1])
-      end
-    end
-    describe 'nondefault value (nonbasic type)' do
-      let(:instance) { [true, [2]] }
-      it 'returns the nondefault value' do
-        assert_is_a(schema.items.jsi_schema_module, subject[1])
-        assert_equal([2], subject[1].as_json)
-      end
-    end
-  end
-  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_is_a(schema.items[2].jsi_schema_module, orig_2)
-      assert_is_a(schema.items[2].jsi_schema_module, subject[2])
-    end
-    it 'modifies the instance, visible to other references to the same instance' do
-      orig_instance = subject.jsi_instance
-
-      subject[2] = {'y' => 'z'}
-
-      assert_equal(orig_instance, subject.jsi_instance)
-      assert_equal({'y' => 'z'}, orig_instance[2])
-      assert_equal({'y' => 'z'}, subject.jsi_instance[2])
-      assert_equal(orig_instance.class, subject.jsi_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_equal("cannot assign subcript (using token: 2) to instance: nil", err.message)
-      end
-    end
-    describe '#inspect' do
-      it 'inspects' do
-        assert_equal("#[<JSI> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print' do
-      it 'pretty_prints' do
-        assert_equal("#[<JSI> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect SortOfArray' do
-      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<JSI SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print SortOfArray' do
-      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
-      it 'pretty_prints' do
-        assert_equal("#[<JSI SortOfArray>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect named' do
-      let(:subject) { NamedArrayInstance.new(instance) }
-      it 'inspects' do
-        assert_equal("#[<NamedArrayInstance> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print named' do
-      let(:subject) { NamedArrayInstance.new(instance) }
-      it 'inspects' do
-        assert_equal("#[<NamedArrayInstance>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect named SortOfArray' do
-      let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<NamedArrayInstance SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print named SortOfArray' do
-      let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<NamedArrayInstance SortOfArray>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect named with id' do
-      let(:subject) { NamedIdArrayInstance.new(instance) }
-      it 'inspects' do
-        assert_equal("#[<NamedIdArrayInstance> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print named with id' do
-      let(:subject) { NamedIdArrayInstance.new(instance) }
-      it 'inspects' do
-        assert_equal("#[<NamedIdArrayInstance>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect named with id SortOfArray' do
-      let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<NamedIdArrayInstance SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print named with id SortOfArray' do
-      let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<NamedIdArrayInstance SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect with id' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(instance) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#)> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print with id' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(instance) }
-      it 'pretty prints' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#)>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect with id SortOfArray' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#) SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print with id SortOfArray' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#) SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
-      end
-    end
-    describe '#inspect Node' do
-      let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
-      it 'inspects' do
-        assert_equal("#[<JSI JSI::JSON::ArrayNode #> \"foo\", \#{<JSI JSI::JSON::HashNode #/1> \"lamp\" => #[<JSI::JSON::ArrayNode #/1/lamp> 3]}, #[<JSI JSI::JSON::ArrayNode #/2> \"q\", \"r\"], \#{<JSI::JSON::HashNode #/3> \"four\" => 4}]", subject.inspect)
-      end
-    end
-    describe '#pretty_print Node' do
-      let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
-      it 'pretty_prints' do
-        assert_equal("#[<JSI JSI::JSON::ArrayNode #>\n  \"foo\",\n  \#{<JSI JSI::JSON::HashNode #/1>\n    \"lamp\" => #[<JSI::JSON::ArrayNode #/1/lamp> 3]\n  },\n  #[<JSI JSI::JSON::ArrayNode #/2> \"q\", \"r\"],\n  \#{<JSI::JSON::HashNode #/3> \"four\" => 4}\n]\n", subject.pretty_inspect)
-      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, 3], subject.each_index.to_a) }
-    it('#empty?')    { assert_equal(false, subject.empty?) }
-    it('#length')   { assert_equal(4, subject.length) }
-    it('#size')    { assert_equal(4, subject.size) }
-  end
-  describe 'index + element methods' do
-    it('#|')  { assert_equal(['foo', subject[1], subject[2], subject[3], 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[3]], subject - ['foo']) }
-    it('#<=>')     { assert_equal(1, subject <=> []) }
-    it('#<=>')      { assert_equal(-1, [] <=> subject) }
-    require 'abbrev'
-    it('#abbrev')    { assert_equal({'a' => 'a'}, schema.new_jsi(['a']).abbrev) }
-    it('#assoc')      { assert_equal(['q', 'r'], subject.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[3]]], 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[3]], subject.drop(2)) }
-    it('#drop_while') { assert_equal([subject[1], subject[2], subject[3]], 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', schema.new_jsi(['a', 'b']).join(' ')) }
-    it('#last')      { assert_equal(subject[3], subject.last) }
-    it('#pack')       { assert_equal(' ', schema.new_jsi([32]).pack('c')) }
-    it('#permutation') { assert_equal([['foo'], [subject[1]], [subject[2]], [subject[3]]], 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 we call #jsi_instance to use it.
-    it('#rassoc')              { assert_equal(['q', 'r'], subject.jsi_instance.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[3], subject[2], subject[1], 'foo'], subject.reverse) }
-    it('#reverse_each')       { assert_equal([subject[3], 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], subject[3], 'foo'], subject.rotate) }
-    it('#sample')          { assert_equal('a', schema.new_jsi(['a']).sample) }
-    it('#shelljoin')      { assert_equal('a', schema.new_jsi(['a']).shelljoin) } if [].respond_to?(:shelljoin)
-    it('#shuffle')       { assert_equal(4, subject.shuffle.size) }
-    it('#slice')        { assert_equal(['foo'], subject.slice(0, 1)) }
-    it('#sort')        { assert_equal(['a'], schema.new_jsi(['a']).sort) }
-    it('#take')       { assert_equal(['foo'], subject.take(1)) }
-    it('#take_while') { assert_equal([], subject.take_while { false }) }
-    it('#transpose') { assert_equal([], schema.new_jsi([]).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[3], subject[3]]], subject.zip(subject)) }
-  end
-  describe 'with an instance that has to_ary but not other ary instance methods' do
-    let(:instance) { SortOfArray.new(['foo', {'lamp' => SortOfArray.new([3])}, SortOfArray.new(['q', 'r'])]) }
-    describe 'delegating instance methods to #to_ary' do
-      it('#each_index') { assert_equal([0, 1, 2], subject.each_index.to_a) }
-      it('#size')      { assert_equal(3, subject.size) }
-      it('#count')    { assert_equal(1, subject.count('foo')) }
-      it('#slice')   { assert_equal(['foo'], subject.slice(0, 1)) }
-      it('#[]')     { assert_equal(SortOfArray.new(['q', 'r']), subject[2].jsi_instance) }
-      it('#as_json') { assert_equal(['foo', {'lamp' => [3]}, ['q', 'r']], subject.as_json) }
-    end
-  end
-  describe 'modified copy methods' do
-    it('#reject') { assert_equal(schema.new_jsi(['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(schema.new_jsi(['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
-      it('#select') do
-        expected = schema.new_jsi(['foo', {'lamp' => [3]}, ['r'], {'four' => 4}])[2]
-        actual = subject[2].select { |e| e == 'r' }
-        assert_equal(expected, actual)
-      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