jschema 0.0.2

data/test/test_schema.rb

@@ -0,0 +1,125 @@
+require 'minitest/autorun'
+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_default_schema_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 'http://example.com/path', uri.to_s
+  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_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_definitions
+    schema_def_uri = '#/definitions/schema1'
+    schema = JSchema::Schema.build('definitions' => { 'schema1' => {} })
+    definition = JSchema::SchemaRef.new(schema_def_uri, schema)
+    assert_equal URI(schema_def_uri), definition.uri
+  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

@@ -0,0 +1,11 @@
+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
+end

data/test/test_validator.rb

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,56 @@
+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

data/test/validator/properties_limit_tests.rb

@@ -0,0 +1,13 @@
+module PropertiesLimitTests
+  def test_that_argument_is_an_integer
+    assert_raises(JSchema::InvalidSchema) { validator 'string' }
+  end
+
+  def test_that_argument_can_be_big_integer
+    validator 2**64
+  end
+
+  def test_that_argument_is_not_negative
+    assert_raises(JSchema::InvalidSchema) { validator(-1) }
+  end
+end

data/test/validator/schema_validation_helpers.rb

@@ -0,0 +1,29 @@
+module SchemaValidationHelpers
+  class SchemaStub
+    def initialize(validation_results)
+      @validation_results = validation_results.cycle
+    end
+
+    def valid?(instance)
+      validate(instance).empty?
+    end
+
+    def validate(instance)
+      result = @validation_results.next
+      result ? [] : ['error']
+    end
+  end
+
+  def stub_schema_validations(*validation_results)
+    schema = SchemaStub.new(validation_results)
+    JSchema::Schema.stub :build, schema do
+      yield
+    end
+  end
+
+  def generate_schema
+    @id ||= 0
+    @id += 1
+    { 'id' => @id.to_s }
+  end
+end

data/test/validator/test_all_of.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+require_relative 'schema_validation_helpers'
+require_relative 'validation_against_schemas_tests'
+
+class TestAllOf < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+  include ValidationAgainstSchemasTests
+
+  def test_passing_validation_against_schemas
+    stub_schema_validations(true, true) do
+      assert validator([generate_schema, generate_schema]).valid?('test')
+    end
+  end
+
+  def test_failing_validation_against_schemas
+    stub_schema_validations(false, true) do
+      refute validator([generate_schema, generate_schema]).valid?('test')
+    end
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::AllOf
+  end
+end

data/test/validator/test_any_of.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+require_relative 'schema_validation_helpers'
+require_relative 'validation_against_schemas_tests'
+
+class TestAnyOf < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+  include ValidationAgainstSchemasTests
+
+  def test_passing_validation_agaist_schemas
+    stub_schema_validations(true, false, true) do
+      schema = [generate_schema, generate_schema, generate_schema]
+      assert validator(schema).valid?('test')
+    end
+  end
+
+  def test_failing_validation_against_schemas
+    stub_schema_validations(false, false) do
+      refute validator([generate_schema, generate_schema]).valid?('test')
+    end
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::AnyOf
+  end
+end

data/test/validator/test_dependencies.rb

@@ -0,0 +1,106 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+require_relative 'schema_validation_helpers'
+
+class TestDependencies < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+
+  def test_that_argument_is_an_object
+    assert_raises_unless 'dependencies', :object
+  end
+
+  def test_that_each_value_of_argument_object_is_either_an_object_or_an_array
+    assert_raises(JSchema::InvalidSchema) do
+      validator('test' => 0)
+    end
+  end
+
+  def test_that_property_dependency_has_at_least_one_element
+    assert_raises(JSchema::InvalidSchema) do
+      validator('test' => [])
+    end
+  end
+
+  def test_that_property_dependency_includes_only_strings
+    assert_raises(JSchema::InvalidSchema) do
+      validator('test' => [0])
+    end
+  end
+
+  def test_that_property_dependency_containt_uniq_elements
+    assert_raises(JSchema::InvalidSchema) do
+      validator('test' => ['property', 'property'])
+    end
+  end
+
+  def test_that_argument_can_contain_schema_and_property_dependencies
+    validator('schema_dependency' => {}, 'property_dependency' => ['test'])
+  end
+
+  def test_passing_schema_dependency_validation
+    stub_schema_validations(true) do
+      assert schema_dependencies_validator.valid?('test' => 0)
+    end
+  end
+
+  def test_failing_schema_dependency_validation
+    stub_schema_validations(false) do
+      refute schema_dependencies_validator.valid?('test' => 0)
+    end
+  end
+
+  def test_passing_validation_when_instance_has_no_dependencies
+    stub_schema_validations(false) do
+      assert schema_dependencies_validator.valid?('other' => 0)
+    end
+  end
+
+  def test_passing_property_dependency_validation
+    expect_required_validation(true) do
+      assert property_dependencies_validator.valid?('test' => 0)
+    end
+  end
+
+  def test_failing_property_dependency_validation
+    expect_required_validation(false) do
+      refute property_dependencies_validator.valid?('test' => 0)
+    end
+  end
+
+  def test_passing_property_dependency_validation_no_dependencies
+    expect_required_validation(false) do
+      assert property_dependencies_validator.valid?('other' => 0)
+    end
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Dependencies
+  end
+
+  def schema_dependencies_validator
+    validator('test' => {})
+  end
+
+  def property_dependencies_validator
+    validator('test' => ['required_property'])
+  end
+
+  def expect_required_validation(valid)
+    validator_stub =
+      Struct.new(:valid) do
+        def validate(_)
+          valid ? [] : ['error']
+        end
+      end
+
+    validator = validator_stub.new(valid)
+    JSchema::Validator::Required.stub :new, validator do
+      yield
+    end
+  end
+end