jschema 0.0.2

data/test/validator/test_enum.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+
+class TestEnum < Minitest::Test
+  include Assertions
+
+  def test_that_argument_is_non_empty_array_of_unique_values
+    assert_raises_unless_non_empty_array 'enum'
+  end
+
+  def test_passing_validation
+    assert validator(['test']).valid?('test')
+  end
+
+  def test_passing_validtion_with_null
+    assert validator([nil]).valid?(nil)
+  end
+
+  def test_failing_validation
+    refute validator(['test']).valid?(0)
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Enum
+  end
+end

data/test/validator/test_format.rb

@@ -0,0 +1,70 @@
+require 'minitest/autorun'
+require_relative 'assertions'
+
+class TestFormat < Minitest::Test
+  include Assertions
+
+  def test_that_argument_is_string
+    assert_raises_unless('format', :string)
+  end
+
+  def test_that_argument_is_one_of_allowed_formats
+    assert_raises(JSchema::InvalidSchema) do
+      validator 'unsupported_format'
+    end
+  end
+
+  def test_passing_validation_by_date_time_format
+    assert validator('date-time').valid?('2001-02-03T04:05:06+07:00')
+  end
+
+  def test_failing_validation_by_date_time_format
+    refute validator('date-time').valid?('2001-x2-03T04:05:06+07:00')
+  end
+
+  def test_passing_validation_by_email_format
+    assert validator('email').valid?('steve@apple.com')
+  end
+
+  def test_failing_validation_by_email_format
+    refute validator('email').valid?('invalid_email')
+  end
+
+  def test_passing_validation_by_hostname_format
+    assert validator('hostname').valid?('apple.com')
+  end
+
+  def test_failing_validation_by_hostname_format
+    refute validator('hostname').valid?('invalid+hostname')
+  end
+
+  def test_passing_validation_by_ipv4_format
+    assert validator('ipv4').valid?('127.0.0.1')
+  end
+
+  def test_failing_validation_by_ipv4_format
+    refute validator('ipv4').valid?('0')
+  end
+
+  def test_passing_validation_by_ipv6_format
+    assert validator('ipv6').valid?('::1')
+  end
+
+  def test_failing_validation_by_ipv6_format
+    refute validator('ipv6').valid?('0')
+  end
+
+  def test_passing_validation_by_uri_format
+    assert validator('uri').valid?('http://example.com/')
+  end
+
+  def test_failing_validation_by_uri_format
+    refute validator('uri').valid?('://')
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Format
+  end
+end

data/test/validator/test_items.rb

@@ -0,0 +1,113 @@
+require 'minitest/autorun'
+require 'jschema'
+
+require_relative 'assertions'
+require_relative 'schema_validation_helpers'
+
+class TestItems < Minitest::Test
+  include Assertions
+  include SchemaValidationHelpers
+
+  def test_that_additional_items_must_be_boolean_or_schema
+    assert_raises_unless 'additionalItems', :boolean, :object
+  end
+
+  def test_that_additional_items_accepts_only_valid_schema
+    assert_raises_unless_schema 'additionalItems'
+  end
+
+  def test_that_items_must_be_object_or_array
+    assert_raises_unless 'items', :object, :array
+  end
+
+  def test_that_items_must_be_a_valid_schema
+    assert_raises_unless_schema 'items'
+  end
+
+  def test_that_items_must_be_schema_array
+    assert_raises_unless_schema_array 'items'
+  end
+
+  def test_passing_validation_by_items_schema
+    stub_schema_validations(true) do
+      assert build_from_schema('items' => {}).valid?(['test'])
+    end
+  end
+
+  def test_passing_validation_by_items_schema_array
+    stub_schema_validations(true) do
+      schema = { 'items' => [generate_schema, generate_schema] }
+      assert build_from_schema(schema).valid?(['test', 'test'])
+    end
+  end
+
+  def test_passing_validation_by_items_when_additional_items_is_omitted
+    stub_schema_validations(true) do
+      schema = { 'items' => [generate_schema] }
+      assert build_from_schema(schema).valid?(['test', 'test'])
+    end
+  end
+
+  def test_passing_validation_by_items_and_additional_items
+    stub_schema_validations(true) do
+      schema = {
+        'items' => [generate_schema],
+        'additionalItems' => generate_schema
+      }
+      assert build_from_schema(schema).valid?(['test', 'test'])
+    end
+  end
+
+  def test_passing_validation_when_additional_items_are_not_allowed
+    stub_schema_validations(true) do
+      schema = {
+        'items' => [generate_schema],
+        'additionalItems' => false
+      }
+      assert build_from_schema(schema).valid?(['test'])
+    end
+  end
+
+  def test_passing_validation_when_instance_size_is_less_than_items_size
+    stub_schema_validations(true) do
+      schema = {
+        'items' => [generate_schema, generate_schema],
+        'additionalItems' => false
+      }
+      assert build_from_schema(schema).valid?(['test'])
+    end
+  end
+
+  def test_failing_validation_when_additional_items_are_not_allowed
+    stub_schema_validations(true) do
+      schema = {
+        'items' => [generate_schema],
+        'additionalItems' => false
+      }
+      refute build_from_schema(schema).valid?(['test', 'test'])
+    end
+  end
+
+  def test_failing_validation_by_items_schema_array
+    stub_schema_validations(false, true) do
+      schema = { 'items' => [generate_schema, generate_schema] }
+      refute build_from_schema(schema).valid?(['test', 'test'])
+    end
+  end
+
+  def test_failing_validation_by_additional_items_schema
+    stub_schema_validations(true, false) do
+      schema = {
+        'items' => [generate_schema],
+        'additionalItems' => generate_schema
+      }
+      refute build_from_schema(schema).valid?(['test', 'test'])
+    end
+  end
+
+  private
+
+  def validator_class
+    JSchema::Validator::Items
+  end
+end

data/test/validator/test_max_items.rb

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

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

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

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

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

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

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