jschema 0.1.1 → 0.1.2

data/test/validator/properties_limit_tests.rb

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

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

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

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

@@ -1,106 +0,0 @@
-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(_)
-          'error' unless valid
-        end
-      end
-
-    validator = validator_stub.new(valid)
-    JSchema::Validator::Required.stub :new, validator do
-      yield
-    end
-  end
-end

data/test/validator/test_enum.rb

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

@@ -1,78 +0,0 @@
-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
-
-  def test_passing_validation_by_regex
-    assert validator('regex').valid?('\d+')
-  end
-
-  def test_failing_validation_by_regex
-    refute validator('regex').valid?('**')
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::Format
-  end
-end

data/test/validator/test_items.rb

@@ -1,119 +0,0 @@
-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_default_value_for_items
-    validator = build_from_schema('additionalItems' => false)
-    assert validator.valid? [1, 2, 3]
-  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
-    basic_schema = generate_schema
-    stub_schema_validations(true) do
-      schema = { 'items' => [basic_schema, basic_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