jschema 0.1.1 → 0.1.2

data/test/validator/test_required.rb

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

@@ -1,107 +0,0 @@
-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_failing_validation_when_validator_is_applicable
-    stub_validator [Fixnum], false do |vdr|
-      refute vdr.valid?(0)
-    end
-  end
-
-  def test_failing_validation_when_instance_is_descendant_of_applicable_types
-    stub_validator [Hash], false do |vdr|
-      descendant_type = Class.new(Hash)
-      refute vdr.valid?(descendant_type.new)
-    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

data/test/validator/test_type.rb

@@ -1,97 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-
-class TestType < Minitest::Test
-  include Assertions
-
-  def test_that_argument_is_a_string_or_an_array
-    assert_raises_unless 'type', :string, :array
-  end
-
-  def test_that_argument_is_a_unique_string_array
-    assert_raises_unless_string_array 'type'
-  end
-
-  def test_passing_string_validation
-    assert validator('string').valid?('str')
-  end
-
-  def test_failing_string_validation
-    refute validator('string').valid?(1)
-  end
-
-  def test_passing_integer_validation
-    assert validator('integer').valid?(1)
-    assert validator('integer').valid?(2**64)
-  end
-
-  def test_failing_integer_validation
-    refute validator('integer').valid?('str')
-  end
-
-  def test_passing_array_validation
-    assert validator('array').valid?([])
-  end
-
-  def test_failing_array_validation
-    refute validator('array').valid?('str')
-  end
-
-  def test_passing_boolean_validation
-    assert validator('boolean').valid?(true)
-    assert validator('boolean').valid?(false)
-  end
-
-  def test_failing_boolean_validation
-    refute validator('boolean').valid?(nil)
-    refute validator('boolean').valid?(0)
-  end
-
-  def test_passing_null_validation
-    assert validator('null').valid?(nil)
-  end
-
-  def test_failing_null_validation
-    refute validator('null').valid?(false)
-    refute validator('null').valid?('')
-  end
-
-  def test_passing_object_validation
-    assert validator('object').valid?('test' => 123)
-  end
-
-  def test_failing_object_validation
-    refute validator('object').valid?([])
-  end
-
-  def test_passing_number_validation
-    assert validator('number').valid?(1)
-    assert validator('number').valid?(1.2)
-    assert validator('number').valid?(BigDecimal.new('1.2'))
-    assert validator('number').valid?(2**64)
-  end
-
-  def test_failing_number_validation
-    refute validator('number').valid?('1')
-  end
-
-  def test_passing_multiple_type_validation
-    mvalidator = validator ['string', 'null']
-    assert mvalidator.valid?('str')
-    assert mvalidator.valid?(nil)
-  end
-
-  def test_failing_multiple_type_validation
-    mvalidator = validator ['string', 'null']
-    refute mvalidator.valid?(1)
-    refute mvalidator.valid?(false)
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::Type
-  end
-end

data/test/validator/test_unique_items.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require 'jschema'
-
-require_relative 'assertions'
-
-class TestUniqueItems < Minitest::Test
-  include Assertions
-
-  def test_that_argument_is_boolean
-    assert_raises_unless 'uniqueItems', :boolean
-  end
-
-  def test_passing_validation_when_unique_items_is_true
-    assert validator(true).valid?([1, 2])
-  end
-
-  def test_passing_validation_when_unique_items_is_false
-    assert validator(false).valid?([1, 1])
-  end
-
-  def test_failing_validation
-    refute validator(true).valid?([1, 1])
-  end
-
-  private
-
-  def validator_class
-    JSchema::Validator::UniqueItems
-  end
-end

data/test/validator/validation_against_schemas_tests.rb

@@ -1,24 +0,0 @@
-require_relative 'argument_is_array_of_schemas_tests'
-
-module ValidationAgainstSchemasTests
-  include SchemaValidationHelpers
-  include ArgumentIsArrayOfSchemasTests
-
-  def test_passing_validation_against_one_schema
-    stub_schema_validations(true) do
-      assert validator([generate_schema]).valid?('test')
-    end
-  end
-
-  def test_failing_validation_against_one_schema
-    stub_schema_validations(false) do
-      refute validator([generate_schema]).valid?('test')
-    end
-  end
-
-  def test_failing_validation_all_validations_fail
-    stub_schema_validations(false, false) do
-      refute validator([generate_schema, generate_schema]).valid?('test')
-    end
-  end
-end