jschema 0.1.1 → 0.1.2

data/test/test_integration.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require 'webmock/minitest'
-require 'jschema'
-require 'json'
-
-class TestIntegration < Minitest::Test
-  def test_simple_schema
-    stub_request(:get, 'http://json-schema.org/geo')
-      .to_return(body: Pathname.new('test/fixtures/geo.json'))
-
-    validate 'json_schema1.json', 'json_data1.json'
-  end
-
-  def test_advanced_schema
-    validate 'json_schema2.json', 'json_data2.json'
-  end
-
-  private
-
-  def validate(schema_file, data_file)
-    sch = json_fixture(schema_file).freeze
-    schema = JSchema::Schema.build(sch)
-    data = json_fixture(data_file)
-    assert schema.valid?(data)
-  end
-
-  def json_fixture(filename)
-    JSON.parse open(File.join('test', 'fixtures', filename)).read
-  end
-end

data/test/test_json_reference.rb

@@ -1,115 +0,0 @@
-require 'minitest/autorun'
-require 'webmock/minitest'
-require 'jschema'
-require 'ostruct'
-
-require_relative 'assert_received'
-
-class TestJSONReference < Minitest::Test
-  def test_schema_registration_and_dereferencing
-    schema = generate_schema('registered')
-    JSchema::JSONReference.register_schema schema
-    assert_equal schema, dereference(schema)
-  end
-
-  def test_schema_dereferencing_with_same_uri
-    schema1 = generate_schema('uri')
-    schema2 = generate_schema('uri')
-    JSchema::JSONReference.register_schema schema1
-    JSchema::JSONReference.register_schema schema2
-
-    assert_equal schema1, dereference(schema1)
-    assert_equal schema2, dereference(schema2)
-  end
-
-  def test_dereferencing_external_schema
-    external_schema = { 'type' => 'number' }
-    schema_uri = 'http://example.com/geo'
-
-    expected_schema_args = [external_schema, URI(schema_uri), nil]
-    assert_received JSchema::Schema, :new, expected_schema_args do
-      JSchema::JSONReference.stub :register_schema, nil do
-        dereference_external_schema schema_uri, external_schema.to_json, false
-      end
-    end
-  end
-
-  def test_that_external_schema_is_cached_after_dereferencing
-    schema = Object.new
-    JSchema::Schema.stub :new, schema do
-      assert_received JSchema::JSONReference, :register_schema, [schema] do
-        dereference_external_schema 'http://example.com', '{}'
-      end
-    end
-  end
-
-  def test_dereferencing_external_schema_when_it_is_not_valid
-    assert_raises(JSchema::InvalidSchema) do
-      dereference_external_schema 'http://example.com/', '}'
-    end
-  end
-
-  def test_dereferencing_external_schema_when_it_is_not_available
-    assert_raises(JSchema::InvalidSchema) do
-      stub_request(:get, //).to_timeout
-      dereference generate_schema('http://example.com/')
-    end
-  end
-
-  def test_dereferencing_external_schema_when_protocol_is_not_supported
-    assert_raises(JSchema::InvalidSchema) do
-      dereference_external_schema 'ftp://example.com/', '{}'
-    end
-  end
-
-  def test_dereferencing_within_schema_with_non_default_uri
-    schema = generate_schema('http://example.com/', false)
-    JSchema::JSONReference.register_schema schema
-    assert_equal schema, JSchema::JSONReference.dereference(URI('#'), schema)
-  end
-
-  def test_dereferencing_root_schema
-    schema1 = generate_schema('#', false)
-    schema2 = generate_schema('http://example.com/', false)
-    JSchema::JSONReference.register_schema schema1
-    JSchema::JSONReference.register_schema schema2
-
-    assert_equal schema2,
-      JSchema::JSONReference.dereference(URI('#'), schema2)
-
-    assert_equal schema2,
-      JSchema::JSONReference.dereference(URI('http://example.com/#'), schema2)
-
-    assert_equal schema2,
-      JSchema::JSONReference.dereference(URI('http://example.com/'), schema2)
-  end
-
-  def test_dereferencing_schema_by_slightly_different_uri
-    schema = generate_schema('http://example.com/#', false)
-    JSchema::JSONReference.register_schema schema
-
-    assert_equal schema,
-      JSchema::JSONReference.dereference(URI('http://example.com/'), schema)
-  end
-
-  private
-
-  def dereference_external_schema(uri, response_schema, parent = true)
-    stub_request(:get, uri).to_return(body: response_schema)
-    dereference generate_schema(uri, parent)
-  end
-
-  def dereference(schema)
-    JSchema::JSONReference.dereference(schema.uri, schema.parent)
-  end
-
-  def generate_schema(uri, parent = true)
-    parent_schema = generate_schema('#', false) if parent
-    OpenStruct.new(uri: URI(uri), id: generate_id, parent: parent_schema)
-  end
-
-  def generate_id
-    @id ||= 0
-    @id += 1
-  end
-end

data/test/test_schema.rb

@@ -1,132 +0,0 @@
-require 'minitest/autorun'
-require 'webmock/minitest'
-require 'jschema'
-
-require_relative 'assert_received'
-
-class TestSchema < Minitest::Test
-  def test_empty_schema
-    JSchema::Validator.stub :build, [] do
-      empty_schema = JSchema::Schema.build
-      assert empty_schema.valid?('test')
-    end
-  end
-
-  def test_passing_validation
-    stub_validators(true) do |schema|
-      assert schema.valid?('instance')
-      assert_empty schema.validate('instance')
-    end
-  end
-
-  def test_failing_validation
-    stub_validators(false) do |schema|
-      refute schema.valid?('instance')
-      refute_empty schema.validate('instance')
-    end
-  end
-
-  def test_json_refenrece
-    schema = Object.new
-    JSchema::SchemaRef.stub :new, schema do
-      schema_ref = JSchema::Schema.build('$ref' => '#/sch')
-      assert_equal schema_ref, schema
-    end
-  end
-
-  def test_that_tilda_is_unescaped
-    expected_ref_uri = URI('#/definitions/sch~')
-    assert_received JSchema::SchemaRef, :new, [expected_ref_uri, nil] do
-      JSchema::Schema.build('$ref' => '#/definitions/sch~0')
-    end
-  end
-
-  def test_that_forward_slash_is_unescaped
-    expected_ref_uri = URI('#/definitions/sch/sch')
-    assert_received JSchema::SchemaRef, :new, [expected_ref_uri, nil] do
-      JSchema::Schema.build('$ref' => '#/definitions/sch~1sch')
-    end
-  end
-
-  def test_storing_schema_in_registry
-    sch = Object.new
-    JSchema::Schema.stub :new, sch do
-      assert_received JSchema::JSONReference, :register_schema, [sch] do
-        JSchema::Schema.build
-      end
-    end
-  end
-
-  # TODO: Make it isolated.
-  def test_schema_caching
-    parent = JSchema::Schema.build
-    sch = { 'type' => 'string' }
-    schema1 = JSchema::Schema.build(sch, parent)
-    schema2 = JSchema::Schema.build(sch, parent)
-    assert_equal schema1.object_id, schema2.object_id
-  end
-
-  # TODO: Make it isolated.
-  def test_that_root_schemas_are_not_cached
-    sch = { 'type' => 'string' }
-    schema1 = JSchema::Schema.build(sch)
-    schema2 = JSchema::Schema.build(sch)
-    refute_equal schema1.object_id, schema2.object_id
-  end
-
-  # TODO: Make it isolated.
-  def test_definitions
-    schema_def_uri = URI('#/definitions/schema1')
-    schema = JSchema::Schema.build('definitions' => { 'schema1' => {} })
-    definition = JSchema::SchemaRef.new(schema_def_uri, schema)
-    assert_equal schema_def_uri, definition.uri
-  end
-
-  # TODO: Make it isolated.
-  def test_definitions
-    schema = JSchema::Schema.build(
-      'definitions' => { 'schema1' => {} },
-      '$ref' => '#/definitions/schema1'
-    )
-
-    schema.valid?('')
-  end
-
-  def test_that_exception_is_raised_when_schema_version_is_not_supported
-    assert_raises(JSchema::InvalidSchema) do
-      JSchema::Schema.build('$schema' => 'unsupported')
-    end
-  end
-
-  def test_to_s
-    schema = JSchema::Schema.build
-    assert_equal '#', schema.to_s
-  end
-
-  def test_simplified_syntax
-    assert_instance_of JSchema::Schema, JSchema.build
-  end
-
-  private
-
-  def stub_validators(ret_val)
-    validator = validator_stub.new(ret_val)
-    JSchema::Validator.stub :build, [validator] do
-      yield JSchema::Schema.build
-    end
-  end
-
-  def validator_stub
-    Struct.new(:valid) do
-      def validate(_)
-        valid ? nil : ['error']
-      end
-    end
-  end
-
-  def schema_uri(schema_id = nil, parent_id = nil, id = nil)
-    parent = JSchema::Schema.build('id' => parent_id) if parent_id || id
-    child = JSchema::Schema.build({ 'id' => schema_id }, parent, id)
-    child.uri
-  end
-end

data/test/test_schema_ref.rb

@@ -1,19 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-class TestSchemaRef < Minitest::Test
-  def test_that_schema_ref_acts_like_schema
-    schema = JSchema::Schema.build
-    JSchema::JSONReference.stub :dereference, schema do
-      assert_equal JSchema::SchemaRef.new(schema.uri, nil), schema
-    end
-  end
-
-  def test_that_exception_is_raised_if_reference_is_incorrect
-    JSchema::JSONReference.stub :dereference, nil do
-      assert_raises(JSchema::InvalidSchema) do
-        JSchema::SchemaRef.new('invalid', nil).parent
-      end
-    end
-  end
-end

data/test/test_schema_uri.rb

@@ -1,56 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-class TestSchemaURI < Minitest::Test
-  def test_default_uri
-    assert_equal URI('#'), schema_uri
-  end
-
-  def test_schema_uri_when_parent_is_not_specified
-    assert_equal URI('test'), schema_uri('test')
-  end
-
-  def test_schema_uri_when_parent_uri_is_absolute
-    uri = schema_uri('test', 'http://example.com/')
-    assert_equal URI('http://example.com/test'), uri
-  end
-
-  def test_schema_uri_when_parent_uri_is_relative
-    assert_raises(JSchema::InvalidSchema) do
-      schema_uri('relative/', 'relative/')
-    end
-  end
-
-  def test_schema_uri_when_both_parent_and_schema_uri_are_absolute
-    schema_id = 'http://example.com/'
-    parent_id = 'http://localhost/'
-    uri = schema_uri(schema_id, parent_id)
-    assert_equal URI(schema_id), uri
-  end
-
-  def test_schema_uri_when_ids_are_not_specified
-    assert_equal URI('#/child'), schema_uri(nil, nil, 'child')
-  end
-
-  def test_that_schema_uri_is_normalized
-    uri = schema_uri('etc/../path', 'http://Example.com')
-    assert_equal URI('http://example.com/path'), uri
-  end
-
-  def test_that_implicit_schema_id_treated_as_uri_fragment
-    uri = schema_uri(nil, 'http://example.com/path#sch', 'sub')
-    assert_equal URI('http://example.com/path#sch/sub'), uri
-  end
-
-  def test_escaping
-    uri = schema_uri(nil, '#/definitions', 'schema%')
-    assert_equal URI('#/definitions/schema%25'), uri
-  end
-
-  private
-
-  def schema_uri(schema_id = nil, parent_id = nil, id = nil)
-    parent_schema = JSchema::Schema.build('id' => parent_id) if parent_id || id
-    JSchema::SchemaURI.build(schema_id, parent_schema, id)
-  end
-end

data/test/test_validator.rb

@@ -1,29 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-class TestValidatorInstantiation < Minitest::Test
-  def test_creating_of_validators
-    return_validator = Object.new
-    assert_equal [return_validator], build_validators(return_validator)
-  end
-
-  def test_parsing_of_empty_schema
-    assert_empty build_validators(nil)
-  end
-
-  private
-
-  def build_validators(return_validator)
-    schema = { 'keyword' => 'arg' }
-    parent_schema = Object.new
-    validator_class = MiniTest::Mock.new
-    validator_class.expect :build, return_validator, [schema, parent_schema]
-    result = JSchema::Validator.stub :constants, [:Test] do
-      JSchema::Validator.stub :const_get, validator_class do
-        JSchema::Validator.build(schema, parent_schema)
-      end
-    end
-    validator_class.verify
-    result
-  end
-end

data/test/validator/argument_is_array_of_schemas_tests.rb

@@ -1,22 +0,0 @@
-module ArgumentIsArrayOfSchemasTests
-  def test_that_argument_is_array
-    assert_raises(JSchema::InvalidSchema) { validator(0) }
-  end
-
-  def test_that_argument_is_not_empty_array
-    assert_raises(JSchema::InvalidSchema) { validator [] }
-  end
-
-  def test_that_argument_contains_only_unique_values
-    assert_raises(JSchema::InvalidSchema) { validator [{}, {}] }
-  end
-
-  def test_that_argument_contains_only_valid_json_schemas
-    assert_raises(JSchema::InvalidSchema) do
-      raises_error = ->(*_) { fail JSchema::InvalidSchema }
-      JSchema::Schema.stub :build, raises_error do
-        validator [{}]
-      end
-    end
-  end
-end

data/test/validator/assertions.rb

@@ -1,56 +0,0 @@
-module Assertions
-  def assert_raises_unless(keyword, *valid_types)
-    basic_types = {
-      array: [], boolean: true, integer: 1,
-      number: 1.2, object: {}, string: 'test'
-    }
-
-    invalid_values = basic_types.select do |type, _|
-      !valid_types.include?(type)
-    end.values
-
-    assert_raises_for_values keyword, invalid_values
-  end
-
-  def assert_raises_unless_schema(keyword, value = {})
-    raises_error = ->(*_) { fail JSchema::InvalidSchema }
-    JSchema::Schema.stub :build, raises_error do
-      assert_raises_for_values keyword, [value]
-    end
-  end
-
-  def assert_raises_unless_schema_array(keyword)
-    assert_raises_unless_schema keyword, [{}]
-  end
-
-  def assert_raises_unless_string_array(keyword)
-    invalid_values = [0, [], ['test', 'test'], [0]]
-    assert_raises_for_values keyword, invalid_values
-  end
-
-  def assert_raises_unless_non_empty_array(keyword)
-    invalid_values = [0, [], ['test', 'test']]
-    assert_raises_for_values keyword, invalid_values
-  end
-
-  def assert_raises_unless_non_negative_integer(keyword)
-    assert_raises_unless keyword, :integer
-    assert_raises_for_values keyword, [-1]
-  end
-
-  def assert_raises_for_values(keyword, invalid_values)
-    invalid_values.each do |invalid_value|
-      assert_raises(JSchema::InvalidSchema) do
-        build_from_schema keyword => invalid_value
-      end
-    end
-  end
-
-  def validator(*args)
-    validator_class.new(*args, nil)
-  end
-
-  def build_from_schema(schema = {})
-    validator_class.build(schema, nil)
-  end
-end