jsi 0.4.0 → 0.7.0

data/test/jsi_typelike_as_json_test.rb

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

data/test/metaschema_node_test.rb

@@ -1,19 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::MetaschemaNode do
-  let(:node_document) { {'properties' => {'properties' => {'additionalProperties' => {'$ref' => '#'}}}} }
-  let(:node_ptr) { JSI::JSON::Pointer[] }
-  let(:metaschema_root_ptr) { JSI::JSON::Pointer[] }
-  let(:root_schema_ptr) { JSI::JSON::Pointer[] }
-  let(:subject) { JSI::MetaschemaNode.new(node_document, node_ptr: node_ptr, metaschema_root_ptr: node_ptr, root_schema_ptr: node_ptr) }
-  describe 'initialization' do
-    it 'initializes' do
-      subject
-    end
-  end
-  describe 'json schema draft' do
-    it 'type has a schema' do
-      assert(JSI::JSONSchemaOrgDraft06.schema.type.jsi_schemas.any?)
-    end
-  end
-end

data/test/schema_module_test.rb

@@ -1,21 +0,0 @@
-require_relative 'test_helper'
-
-describe 'JSI::SchemaModule' do
-  let(:schema_content) { {'properties' => {'foo' => {'items' => {'type' => 'string'}}}} }
-  let(:schema) { JSI::Schema.new(schema_content) }
-  let(:schema_module) { schema.jsi_schema_module }
-  describe 'accessors and subscripts' do
-    it 'returns schemas using accessors and subscripts' do
-      assert_equal(schema.properties, schema_module.properties.possibly_schema_node)
-      assert_equal(schema.properties['foo'], schema_module.properties['foo'].possibly_schema_node)
-      assert_equal(schema.properties['foo'].jsi_schema_module, schema_module.properties['foo'])
-      assert_equal(schema.properties['foo'].items, schema_module.properties['foo'].items.possibly_schema_node)
-      assert_equal(schema.properties['foo'].items.jsi_schema_module, schema_module.properties['foo'].items)
-      assert_equal('string', schema_module.properties['foo'].items.type)
-    end
-    it 'accessors and subscripts with a metaschema' do
-      assert_equal(JSI::JSONSchemaOrgDraft06.schema.properties, JSI::JSONSchemaOrgDraft06.properties.possibly_schema_node)
-      assert_equal(JSI::JSONSchemaOrgDraft06.schema.properties['properties'].additionalProperties.jsi_schema_module, JSI::JSONSchemaOrgDraft06.properties['properties'].additionalProperties)
-    end
-  end
-end

data/test/schema_test.rb

@@ -1,208 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::Schema do
-  describe 'new' do
-    it 'initializes from a hash' do
-      schema = JSI::Schema.new({'type' => 'object'})
-      assert_equal({'type' => 'object'}, schema.jsi_instance)
-    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.jsi_instance)
-    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 'instantiating a schema from schema returns that schema' do
-      # this is kinda dumb, but Schema.new now just aliases Schema.from_object, so this is the behavior
-      assert_equal(JSI::Schema.new({}), JSI::Schema.new(JSI::Schema.new({})))
-    end
-  end
-  describe 'as an instance of metaschema' do
-    let(:metaschema_jsi_module) { JSI::JSONSchemaOrgDraft04 }
-    let(:schema_content) { {'type' => 'array', 'items' => {'description' => 'items!'}} }
-    let(:schema) { metaschema_jsi_module.new_jsi(schema_content) }
-    it '#[]' do
-      schema_items = schema['items']
-      assert_is_a(metaschema_jsi_module, schema_items)
-      assert_equal({'description' => 'items!'}, schema_items.as_json)
-    end
-  end
-  describe '#schema_id' do
-    it "hasn't got one" do
-      assert_nil(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_with_fragment#'})
-      assert_equal('https://schemas.jsi.unth.net/test/given_id_with_fragment#', 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 = JSI::Schema.new({
-        'id' => 'https://schemas.jsi.unth.net/test/uses_pointer_in_fragment#',
-        'properties' => {'foo' => {'type' => 'object'}},
-      })
-      subschema = schema['properties']['foo']
-      assert_equal('https://schemas.jsi.unth.net/test/uses_pointer_in_fragment#/properties/foo', subschema.schema_id)
-    end
-    it 'uses a pointer in the fragment relative to the fragment of the root' do
-      schema = JSI::Schema.new({
-        'id' => 'https://schemas.jsi.unth.net/test/id_has_pointer#/notroot',
-        'properties' => {'foo' => {'type' => 'object'}},
-      })
-      subschema = schema['properties']['foo']
-      assert_equal('https://schemas.jsi.unth.net/test/id_has_pointer#/notroot/properties/foo', subschema.schema_id)
-    end
-  end
-  describe '#jsi_schema_module' do
-    it 'returns the module for the schema' do
-      schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/jsi_schema_module'})
-      assert_is_a(JSI::SchemaModule, schema.jsi_schema_module)
-      assert_equal(schema, schema.jsi_schema_module.schema)
-    end
-  end
-  describe '#jsi_schema_class' do
-    it 'returns the class for the schema' do
-      schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/schema_schema_class'})
-      assert_equal(JSI.class_for_schemas([schema]), schema.jsi_schema_class)
-    end
-  end
-  describe '#subschemas_for_property_name' do
-    let(:schema) do
-      JSI::Schema.new({
-        properties: {
-          foo: {description: 'foo'},
-          baz: {description: 'baz'},
-        },
-        patternProperties: {
-          "^b" => {description: 'ba*'},
-        },
-        additionalProperties: {description: 'whatever'},
-      })
-    end
-    it 'has no subschemas' do
-      assert_empty(JSI::Schema.new({}).subschemas_for_property_name('no'))
-    end
-    it 'has a subschema by property' do
-      subschemas = schema.subschemas_for_property_name('foo').to_a
-      assert_equal(1, subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
-      assert_equal('foo', subschemas[0].description)
-    end
-    it 'has subschemas by patternProperties' do
-      subschemas = schema.subschemas_for_property_name('bar').to_a
-      assert_equal(1, subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
-      assert_equal('ba*', subschemas[0].description)
-    end
-    it 'has subschemas by properties, patternProperties' do
-      subschemas = schema.subschemas_for_property_name('baz').to_a
-      assert_equal(2, subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
-      assert_equal('baz', subschemas[0].description)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[1])
-      assert_equal('ba*', subschemas[1].description)
-    end
-    it 'has subschemas by additional properties' do
-      subschemas = schema.subschemas_for_property_name('anything').to_a
-      assert_equal(1, subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
-      assert_equal('whatever', subschemas[0].description)
-    end
-  end
-  describe '#subschemas_for_index' do
-    it 'has no subschemas' do
-      assert_empty(JSI::Schema.new({}).subschemas_for_index(0))
-    end
-    it 'has a subschema for items' do
-      schema = JSI::Schema.new({
-        items: {description: 'items!'}
-      })
-      first_subschemas = schema.subschemas_for_index(0).to_a
-      assert_equal(1, first_subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
-      assert_equal('items!', first_subschemas[0].description)
-      last_subschemas = schema.subschemas_for_index(1).to_a
-      assert_equal(1, last_subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
-      assert_equal('items!', last_subschemas[0].description)
-    end
-    it 'has a subschema for each item by index' do
-      schema = JSI::Schema.new({
-        items: [{description: 'item one'}, {description: 'item two'}]
-      })
-      first_subschemas = schema.subschemas_for_index(0).to_a
-      assert_equal(1, first_subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
-      assert_equal('item one', first_subschemas[0].description)
-      last_subschemas = schema.subschemas_for_index(1).to_a
-      assert_equal(1, last_subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
-      assert_equal('item two', last_subschemas[0].description)
-    end
-    it 'has a subschema by additional items' do
-      schema = JSI::Schema.new({
-        items: [{description: 'item one'}],
-        additionalItems: {description: "mo' crap"},
-      })
-      first_subschemas = schema.subschemas_for_index(0).to_a
-      assert_equal(1, first_subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
-      assert_equal('item one', first_subschemas[0].description)
-      last_subschemas = schema.subschemas_for_index(1).to_a
-      assert_equal(1, last_subschemas.size)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
-      assert_equal("mo' crap", last_subschemas[0].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("\#{<JSI (JSI::JSONSchemaOrgDraft06) Schema> \"id\" => \"https://schemas.jsi.unth.net/test/stringification\", \"type\" => \"object\"}", schema.inspect)
-    end
-    it '#pretty_print' do
-      assert_equal("\#{<JSI (JSI::JSONSchemaOrgDraft06) Schema>
-        \"id\" => \"https://schemas.jsi.unth.net/test/stringification\",
-        \"type\" => \"object\"
-      }".gsub(/^      /, ''), schema.pretty_inspect.chomp)
-    end
-  end
-  describe 'validation' do
-    let(:schema) { JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/validation', type: 'object'}) }
-    describe 'without errors' do
-      let(:instance) { {'foo' => 'bar'} }
-      it '#fully_validate_instance' do
-        assert_equal([], schema.fully_validate_instance(instance))
-      end
-      it '#validate_instance' do
-        assert_equal(true, schema.validate_instance(instance))
-      end
-      it '#validate_instance!' do
-        assert_equal(true, schema.validate_instance!(instance))
-      end
-    end
-    describe 'with errors' do
-      let(:instance) { ['no'] }
-      it '#fully_validate_instance' do
-        assert_equal(["The property '#/' of type array did not match the following type: object in schema https://schemas.jsi.unth.net/test/validation"], schema.fully_validate_instance(instance))
-      end
-      it '#validate_instance' do
-        assert_equal(false, schema.validate_instance(instance))
-      end
-      it '#validate_instance!' do
-        err = assert_raises(JSON::Schema::ValidationError) do
-          schema.validate_instance!(instance)
-        end
-        assert_equal("The property '#/' of type array did not match the following type: object", err.message)
-      end
-    end
-  end
-end

data/test/spreedly_openapi_test.rb

@@ -1,8 +0,0 @@
-require_relative 'test_helper'
-
-require 'spreedly_openapi'
-describe 'spreedly openapi' do
-  it 'instantiates the spreedly openapi doc' do
-    SpreedlyOpenAPI::Document.inspect
-  end
-end

data/test/test_helper.rb

@@ -1,97 +0,0 @@
-require 'coveralls'
-if Coveralls.will_run?
-  Coveralls.wear!
-end
-require 'simplecov'
-
-require 'bundler/setup'
-
-require 'byebug'
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'jsi'
-
-# NO EXPECTATIONS
-ENV["MT_NO_EXPECTATIONS"] = ''
-
-require 'minitest/autorun'
-require 'minitest/around/spec'
-require 'minitest/reporters'
-
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
-class JSISpec < Minitest::Spec
-  if ENV['JSI_TEST_ALPHA']
-    # :nocov:
-    define_singleton_method(:test_order) { :alpha }
-    # :nocov:
-  end
-
-  def assert_equal exp, act, msg = nil
-    msg = message(msg, E) do
-      [].tap do |ms|
-        ms << diff(exp, act)
-        ms << "#{ANSI.red   { 'expected' }}: #{exp.inspect}"
-        ms << "#{ANSI.green { 'actual' }}:   #{act.inspect}"
-        if exp.respond_to?(:to_str) && act.respond_to?(:to_str)
-          ms << "#{ANSI.red { 'expected (str)' }}:"
-          ms << exp
-          ms << "#{ANSI.green { 'actual (str)' }}:"
-          ms << act
-        end
-      end.join("\n")
-    end
-    assert exp == act, msg
-  end
-
-  def assert_match matcher, obj, msg = nil
-    msg = message(msg) do
-      [].tap do |ms|
-        ms << "Expected match."
-        ms << "#{ANSI.red   { 'matcher' }}: #{mu_pp matcher}"
-        ms << "#{ANSI.green { 'object' }}:  #{mu_pp obj}"
-        ms << "#{ANSI.yellow { 'escaped' }}: #{Regexp.new(Regexp.escape(obj)).inspect}" if obj.is_a?(String)
-      end.join("\n")
-    end
-    assert_respond_to matcher, :"=~"
-    matcher = Regexp.new Regexp.escape matcher if String === matcher
-    assert matcher =~ obj, msg
-  end
-
-  def assert_is_a mod, obj, msg = nil
-    msg = message(msg) { "Expected instance of #{mod}. received #{obj.class}: #{mu_pp(obj)}" }
-
-    assert obj.is_a?(mod), msg
-  end
-end
-
-# register this to be the base class for specs instead of Minitest::Spec
-Minitest::Spec.register_spec_type(//, JSISpec)
-
-# tests support of things that duck-type #to_hash
-class SortOfHash
-  def initialize(hash)
-    @hash = hash
-  end
-  def to_hash
-    @hash
-  end
-  include JSI::Util::FingerprintHash
-  def jsi_fingerprint
-    {class: self.class, hash: @hash}
-  end
-end
-
-# tests support of things that duck-type #to_ary
-class SortOfArray
-  def initialize(ary)
-    @ary = ary
-  end
-  def to_ary
-    @ary
-  end
-  include JSI::Util::FingerprintHash
-  def jsi_fingerprint
-    {class: self.class, ary: @ary}
-  end
-end

data/test/util_test.rb

@@ -1,62 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::Util do
-  describe '.stringify_symbol_keys' do
-    it 'stringifies symbol hash keys' do
-      assert_equal({'a' => 'b', 'c' => 'd', nil => 3}, JSI.stringify_symbol_keys({a: 'b', 'c' => 'd', nil => 3}))
-    end
-    it 'stringifies HashNode keys' do
-      actual = JSI.stringify_symbol_keys(JSI::JSON::Node.new_doc({a: 'b', 'c' => 'd', nil => 3}))
-      expected = JSI::JSON::Node.new_doc({'a' => 'b', 'c' => 'd', nil => 3})
-      assert_equal(expected, actual)
-    end
-    it 'stringifies JSI hash keys' do
-      schema = JSI::Schema.new({type: 'object'})
-      expected = JSI.stringify_symbol_keys(schema.new_jsi({a: 'b', 'c' => 'd', nil => 3}))
-      actual = schema.new_jsi({'a' => 'b', 'c' => 'd', nil => 3})
-      assert_equal(expected, actual)
-    end
-    describe 'non-hash-like argument' do
-      it 'errors' do
-        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(nil) }
-        assert_equal("expected argument to be a hash; got NilClass: nil", err.message)
-        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI::JSON::Node.new_doc(3)) }
-        assert_equal("expected argument to be a hash; got JSI::JSON::Node: #<JSI::JSON::Node # 3>", err.message)
-        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI::Schema.new({}).new_jsi(3)) }
-        assert_equal("expected argument to be a hash; got (JSI Schema Class: #): #<JSI 3>", err.message)
-      end
-    end
-  end
-  describe '.deep_stringify_symbol_keys' do
-    it 'stringifies symbol hash keys' do
-      actual = JSI.deep_stringify_symbol_keys({
-        a: 'b',
-        'c' => [
-          {d: true},
-          [{'e' => 0}],
-        ],
-        nil => 3,
-      })
-      expected = {
-        'a' => 'b',
-        'c' => [
-          {'d' => true},
-          [{'e' => 0}],
-        ],
-        nil => 3,
-      }
-      assert_equal(expected, actual)
-    end
-    it 'deep stringifies HashNode keys' do
-      actual = JSI.deep_stringify_symbol_keys(JSI::JSON::Node.new_doc({a: 'b', 'c' => {d: 0}, nil => 3}))
-      expected = JSI::JSON::Node.new_doc({'a' => 'b', 'c' => {'d' => 0}, nil => 3})
-      assert_equal(expected, actual)
-    end
-    it 'deep stringifies JSI instance' do
-      schema = JSI::Schema.new(type: 'object')
-      actual = JSI.deep_stringify_symbol_keys(schema.new_jsi(JSI::JSON::Node.new_doc({a: 'b', 'c' => {d: 0}, nil => 3})))
-      expected = schema.new_jsi(JSI::JSON::Node.new_doc({'a' => 'b', 'c' => {'d' => 0}, nil => 3}))
-      assert_equal(expected, actual)
-    end
-  end
-end