jschema 0.1.1 → 0.1.2

data/test/validator/test_max_items.rb

@@ -1,26 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-
-class TestMaxItems < Minitest::Test
-  include Assertions
-
-  def test_that_argument_is_non_negative_iteger
-    assert_raises_unless_non_negative_integer 'maxItems'
-  end
-
-  def test_passing_validation
-    assert validator(3).valid?([1, 2])
-  end
-
-  def test_failing_validation
-    refute validator(2).valid?([1, 2, 3])
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::MaxItems
-  end
-end

data/test/validator/test_max_length.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-require_relative '../string_length_validator_tests'
-
-class TestMaxLength < Minitest::Test
-  include Assertions
-  include StringLengthValidatorTests
-
-  def test_that_argument_is_a_positive_number
-    assert_raises_for_values 'maxLength', [0]
-  end
-
-  def test_passing_validation
-    assert validator(4).valid?('test')
-    assert validator(10).valid?('test')
-    assert validator(10).valid?('')
-  end
-
-  def test_failing_validation
-    refute validator(3).valid?('test')
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::MaxLength
-  end
-end

data/test/validator/test_max_properties.rb

@@ -1,29 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-require_relative 'properties_limit_tests'
-
-class TestMaxProperties < Minitest::Test
-  include Assertions
-  include PropertiesLimitTests
-
-  def test_building_validator_from_schema
-    validator = build_from_schema('maxProperties' => 10)
-    assert_instance_of JSchema::Validator::MaxProperties, validator
-  end
-
-  def test_passing_validation
-    assert validator(1).valid?('test' => 1)
-  end
-
-  def test_failing_validation
-    refute validator(1).valid?('test1' => 1, 'test2' => 2)
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::MaxProperties
-  end
-end

data/test/validator/test_maximum.rb

@@ -1,58 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-
-class TestMaximum < Minitest::Test
-  include Assertions
-
-  def test_that_maximum_is_a_number
-    assert_raises_unless 'maximum', :integer, :number
-  end
-
-  def test_that_exclusive_maximum_is_boolean
-    assert_raises(JSchema::InvalidSchema) do
-      build_from_schema('maximum' => 1, 'exclusiveMaximum' => 0)
-    end
-  end
-
-  def test_that_exclusive_maximum_can_not_be_specified_without_maximum
-    assert_raises(JSchema::InvalidSchema) do
-      build_from_schema('exclusiveMaximum' => false)
-    end
-  end
-
-  def test_passing_validation_when_exclusive_maximum_is_not_specified
-    assert build_from_schema('maximum' => 3).valid?(2)
-  end
-
-  def test_passing_validation_when_exclusive_maximum_is_false
-    schema = build_from_schema('maximum' => 2, 'exclusiveMaximum' => false)
-    assert schema.valid?(2)
-  end
-
-  def test_passing_validation_when_exclusive_maximum_is_true
-    schema = build_from_schema('maximum' => 3, 'exclusiveMaximum' => true)
-    assert schema.valid?(2)
-  end
-
-  def test_failing_validation_when_exclusive_maximum_is_not_specified
-    refute build_from_schema('maximum' => 1).valid?(2)
-  end
-
-  def test_failing_validation_when_exclusive_maximum_is_false
-    schema = build_from_schema('maximum' => 1, 'exclusiveMaximum' => false)
-    refute schema.valid?(2)
-  end
-
-  def test_failing_validation_when_exclusive_maximum_is_true
-    schema = build_from_schema('maximum' => 1, 'exclusiveMaximum' => true)
-    refute schema.valid?(1)
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::Maximum
-  end
-end

data/test/validator/test_min_items.rb

@@ -1,27 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-
-class TestMinItems < Minitest::Test
-  include Assertions
-
-  def test_that_argument_is_non_negative_iteger
-    assert_raises_unless_non_negative_integer 'minItems'
-  end
-
-  def test_passing_validation
-    assert validator(1).valid?([1, 2])
-    assert validator(1).valid?([1])
-  end
-
-  def test_failing_validation
-    refute validator(2).valid?([1])
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::MinItems
-  end
-end

data/test/validator/test_min_length.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-require_relative '../string_length_validator_tests'
-
-class TestMinLength < Minitest::Test
-  include Assertions
-  include StringLengthValidatorTests
-
-  def test_that_argument_is_not_a_negative_number
-    assert_raises_unless_non_negative_integer 'minLength'
-  end
-
-  def test_passing_validation
-    assert validator(4).valid?('test')
-    assert validator(3).valid?('test')
-    assert validator(0).valid?('')
-  end
-
-  def test_failing_validation
-    refute validator(5).valid?('test')
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::MinLength
-  end
-end

data/test/validator/test_min_properties.rb

@@ -1,29 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-require_relative 'properties_limit_tests'
-
-class TestMinProperties < Minitest::Test
-  include Assertions
-  include PropertiesLimitTests
-
-  def test_building_validator_from_schema
-    validator = build_from_schema('minProperties' => 10)
-    assert_instance_of JSchema::Validator::MinProperties, validator
-  end
-
-  def test_passing_validation
-    assert validator(0).valid?('test' => 1)
-  end
-
-  def test_failing_validation
-    refute validator(3).valid?('test1' => 1, 'test2' => 2)
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::MinProperties
-  end
-end

data/test/validator/test_minimum.rb

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

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

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

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

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

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