jschema 0.0.2

data/test/validator/test_minimum.rb

@@ -0,0 +1,58 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+
+class TestMinimum < Minitest::Test
+  include Assertions
+
+  def test_that_minimum_is_a_number
+    assert_raises_unless 'minimum', :integer, :number
+  end
+
+  def test_that_exclusive_minimum_is_boolean
+    assert_raises(JSchema::InvalidSchema) do
+      build_from_schema('minimum' => 1, 'exclusiveMinimum' => 0)
+    end
+  end
+
+  def test_that_exclusive_minimum_can_not_be_specified_without_minimum
+    assert_raises(JSchema::InvalidSchema) do
+      build_from_schema('exclusiveMinimum' => false)
+    end
+  end
+
+  def test_passing_validation_when_exclusive_minimum_is_not_specified
+    assert build_from_schema('minimum' => 1).valid?(2)
+  end
+
+  def test_passing_validation_when_exclusive_minimum_is_false
+    schema = build_from_schema('minimum' => 2, 'exclusiveMinimum' => false)
+    assert schema.valid?(2)
+  end
+
+  def test_passing_validation_when_exclusive_minimum_is_true
+    schema = build_from_schema('minimum' => 1, 'exclusiveMinimum' => true)
+    assert schema.valid?(2)
+  end
+
+  def test_failing_validation_when_exclusive_minumum_is_not_specified
+    refute build_from_schema('minimum' => 2).valid?(1)
+  end
+
+  def test_failing_validation_when_exclusive_minimum_is_false
+    schema = build_from_schema('minimum' => 2, 'exclusiveMinimum' => false)
+    refute schema.valid?(1)
+  end
+
+  def test_failing_validation_when_exclusive_minimum_is_true
+    schema = build_from_schema('minimum' => 1, 'exclusiveMinimum' => true)
+    refute schema.valid?(1)
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Minimum
+  end
+end

data/test/validator/test_multiple_of.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+
+class TestMultipleOf < Minitest::Test
+  include Assertions
+
+  def test_that_argument_is_a_number
+    assert_raises_unless 'multipleOf', :number, :integer
+  end
+
+  def test_that_argument_is_a_positive_number
+    assert_raises_for_values 'multipleOf', [0, -0.5]
+  end
+
+  def test_passing_validation_when_argument_is_integer
+    assert validator(2).valid?(4)
+  end
+
+  def test_passing_validation_when_argument_is_float
+    assert validator(1.2).valid?(3.6)
+  end
+
+  def test_passing_validation_when_instance_is_negative
+    assert validator(1.2).valid?(-3.6)
+  end
+
+  def test_failing_validation
+    refute validator(3).valid?(7)
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::MultipleOf
+  end
+end

data/test/validator/test_not.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+require_relative 'schema_validation_helpers'
+
+class TestNot < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+
+  def test_that_argument_is_schema
+    assert_raises_unless_schema 'not'
+  end
+
+  def test_passing_validation
+    stub_schema_validations(false) do
+      assert validator({}).valid?('test')
+    end
+  end
+
+  def test_failing_validation
+    stub_schema_validations(true) do
+      refute validator({}).valid?('test')
+    end
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Not
+  end
+end

data/test/validator/test_one_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 TestOneOf < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+  include ValidationAgainstSchemasTests
+
+  def test_passing_validation_against_schemas
+    stub_schema_validations(true, false, false) do
+      schemas = [generate_schema, generate_schema, generate_schema]
+      assert validator(schemas).valid?('test')
+    end
+  end
+
+  def test_failing_validation_when_more_than_one_validation_passes
+    stub_schema_validations(true) do
+      refute validator([generate_schema, generate_schema]).valid?('test')
+    end
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::OneOf
+  end
+end

data/test/validator/test_pattern.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+
+class TestPattern < Minitest::Test
+  include Assertions
+
+  def test_that_only_valid_regexp_is_allowed
+    assert_raises_unless 'pattern', :string
+  end
+
+  def test_that_validation_always_passes_for_non_strings
+    assert validator('123').valid?(nil)
+    assert validator('123').valid?([])
+  end
+
+  def test_passing_validation
+    assert validator('123').valid?('test123')
+    assert validator('\d+$').valid?('test123')
+  end
+
+  def test_failing_validation
+    refute validator('123').valid?('test')
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Pattern
+  end
+end

data/test/validator/test_properties.rb

@@ -0,0 +1,136 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+require_relative 'schema_validation_helpers'
+
+# rubocop:disable ClassLength
+class TestProperties < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+
+  def test_invalid_properties_argument
+    keywords.each do |keyword|
+      assert_raises(JSchema::InvalidSchema) do
+        build_from_schema(keyword => 1)
+      end
+    end
+  end
+
+  def test_invalid_properties_schema_argument
+    keywords.each do |keyword|
+      assert_raises(JSchema::InvalidSchema) do
+        build_from_schema(keyword => { 'test' => 1 })
+      end
+    end
+  end
+
+  def test_passing_properties_validation_by_sub_schema
+    keywords.each do |keyword|
+      assert_passing_validation keyword
+    end
+  end
+
+  def test_failing_properties_validation_by_sub_schema
+    keywords.each do |keyword|
+      assert_failing_validation keyword
+    end
+  end
+
+  def test_passing_validation_when_additional_properties_are_not_allowed
+    assert validator_with_additional_properties.valid?('test' => 123)
+  end
+
+  def test_failing_validation_when_additional_properties_are_not_allowed
+    refute validator_with_additional_properties.valid?(
+      'test' => 123, 'additional' => 321)
+  end
+
+  def test_passing_validation_when_additional_properties_are_allowed
+    validator = build_from_schema(
+      'additionalProperties' => true,
+      'properties' => { 'test' => {} }
+    )
+
+    assert validator.valid?('test' => 123, 'additional' => true)
+  end
+
+  def test_passing_validation_with_additional_and_pattern_properties
+    validator = validator_with_additional_and_pattern_properties
+    assert validator.valid?('test123' => true)
+  end
+
+  def test_failing_validation_with_additional_and_pattern_properties
+    validator = validator_with_additional_and_pattern_properties
+    refute validator.valid?('test' => true)
+  end
+
+  def test_passing_validation_when_any_properties_are_disallowed
+    assert validator_with_disallowed_properties.valid?({})
+  end
+
+  def test_failing_validation_when_any_properties_are_disallowed
+    refute validator_with_disallowed_properties.valid?('test' => 123)
+  end
+
+  def test_that_validation_always_passes_for_non_object_instances
+    validator = build_from_schema('additionalProperties' => false)
+    assert validator.valid?('test')
+  end
+
+  def test_building_validator_from_properties
+    validator = build_from_schema('properties' => { 'test' => {} })
+    assert_instance_of JSchema::Validator::Properties, validator
+  end
+
+  def test_building_validator_from_additional_properties
+    validator = build_from_schema('additionalProperties' => false)
+    assert_instance_of JSchema::Validator::Properties, validator
+  end
+
+  def test_building_validator_from_empty_schema
+    assert_nil build_from_schema({})
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Properties
+  end
+
+  def keywords
+    ['properties', 'patternProperties', 'additionalProperties']
+  end
+
+  def validator_with_additional_properties
+    build_from_schema(
+      'additionalProperties' => false,
+      'properties' => { 'test' => {} }
+    )
+  end
+
+  def validator_with_additional_and_pattern_properties
+    build_from_schema(
+      'additionalProperties' => false,
+      'patternProperties' => { '\d+' => {} }
+    )
+  end
+
+  def validator_with_disallowed_properties
+    build_from_schema('additionalProperties' => false)
+  end
+
+  def assert_passing_validation(keyword)
+    stub_schema_validations(true) do
+      validator = build_from_schema(keyword => { 'test' => {} })
+      assert validator.valid?('test' => 123)
+    end
+  end
+
+  def assert_failing_validation(keyword)
+    stub_schema_validations(false) do
+      validator = build_from_schema(keyword => { 'test' => {} })
+      refute validator.valid?('test' => 123)
+    end
+  end
+end

data/test/validator/test_required.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+
+class TestRequired < Minitest::Test
+  include Assertions
+
+  def test_that_argument_is_string_array
+    assert_raises_unless_string_array 'required'
+  end
+
+  def test_passing_validation
+    assert validator(['test']).valid?('test' => 123)
+  end
+
+  def test_passing_validation_when_property_has_false_value
+    assert validator(['test']).valid?('test' => false)
+  end
+
+  def test_failing_validation
+    refute validator(['test']).valid?({})
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Required
+  end
+end

data/test/validator/test_simple_validator.rb

@@ -0,0 +1,100 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+
+class TestSimpleValidator < Minitest::Test
+  include Assertions
+
+  def setup
+    super
+    @validator_class = Class.new(JSchema::SimpleValidator) do
+      private
+
+      self.keywords = ['param']
+
+      def validate_args(param)
+        true
+      end
+
+      def post_initialize(param)
+      end
+
+      def validate_instance(param)
+      end
+
+      def applicable_types
+        [String]
+      end
+    end
+  end
+
+  def test_parent_attribute
+    parent = Object.new
+    example = @validator_class.new('param', parent)
+    assert_equal parent, example.parent
+  end
+
+  def test_building_from_schema
+    validator_example = build_from_schema('param' => 'test')
+    assert_instance_of validator_class, validator_example
+  end
+
+  def test_building_from_empty_schema
+    assert_nil build_from_schema
+  end
+
+  def test_passing_validation
+    stub_validator nil, true do |vdr|
+      assert vdr.valid?('instance')
+      assert_nil vdr.validate('instance')
+    end
+  end
+
+  def test_failing_validation
+    stub_validator nil, false do |vdr|
+      refute vdr.valid?('instance')
+      assert_equal 'error', vdr.validate('instance')
+    end
+  end
+
+  def test_invalid_params
+    assert_raises(JSchema::InvalidSchema) do
+      Class.new(JSchema::SimpleValidator) do
+        private
+
+        def validate_args
+          false
+        end
+      end.new('test')
+    end
+  end
+
+  def test_that_validation_always_passes_if_validator_is_not_applicable
+    stub_validator [Fixnum], false do |vdr|
+      assert vdr.valid?('instance')
+    end
+  end
+
+  def test_applicable_types
+    stub_validator [Fixnum], false do |vdr|
+      refute vdr.valid?(0)
+    end
+  end
+
+  private
+
+  def stub_validator(applicable_types, valid)
+    validator_example = validator 'test'
+    validation_result = valid ? nil : 'error'
+    validator_example.stub :applicable_types, applicable_types do
+      validator_example.stub :validate_instance, validation_result do
+        yield validator_example
+      end
+    end
+  end
+
+  def validator_class
+    @validator_class
+  end
+end