respect 0.1.0

data/test/fake_name_proxy_test.rb

@@ -0,0 +1,138 @@
+require "test_helper"
+
+class FakeNameProxyTest < Test::Unit::TestCase
+
+  def setup
+    @def_class = Class.new(Respect::GlobalDef) do
+      include Respect::CoreStatements
+      def accept_name(name)
+        name
+      end
+      def do_not_accept_name(arg1)
+        arg1
+      end
+      def method_missing(symbol, *args, &block)
+        [symbol, args, block]
+      end
+      def respond_to_missing?(symbol, include_all)
+        symbol == :dynamic_method
+      end
+    end
+    @def_target = @def_class.new
+    @evaluator = Respect::FakeNameProxy.new(@def_target)
+
+    @def_class_no_name = @def_class.clone
+    @def_class_no_name.send(:include, Respect::DefWithoutName)
+    @def_target_no_name = @def_class_no_name.new
+    @evaluator_no_name = Respect::FakeNameProxy.new(@def_target_no_name)
+  end
+
+  def test_consider_name_as_accepted_by_default
+    assert(!@evaluator.__send__(:should_fake_name?))
+    assert(@evaluator_no_name.__send__(:should_fake_name?))
+  end
+
+  def test_access_to_target
+    assert(@def_target == @evaluator.target)
+    assert(@def_class == @evaluator.target.class)
+    @evaluator.eval do |e|
+      assert(e == @evaluator)
+      assert(e.target == @def_target)
+      assert(e.target.class == @def_class)
+    end
+  end
+
+  def test_nil_inserted_as_fake_name
+    @evaluator_no_name.eval do |e|
+      assert_nil e.accept_name
+      assert_raise(ArgumentError) do
+        e.accept_name "extra arg"
+      end
+      assert_raise(ArgumentError) do
+        e.do_not_accept_name
+      end
+      assert_equal("arg1", e.do_not_accept_name("arg1"))
+    end
+  end
+
+  def test_nothing_inserted_as_fake_name
+    @evaluator.eval do |e|
+      assert_equal("name", e.accept_name("name"))
+      assert_raise(ArgumentError) do
+        e.accept_name
+      end
+      assert_raise(ArgumentError) do
+        e.accept_name "name", "extra arg"
+      end
+      assert_raise(ArgumentError) do
+        e.do_not_accept_name
+      end
+      assert_equal("arg1", e.do_not_accept_name("arg1"))
+      assert_raise(ArgumentError) do
+        e.do_not_accept_name "arg1", "extra arg"
+      end
+    end
+  end
+
+  def test_rewrite_argument_error_message_values
+    @evaluator_no_name.eval do |e|
+      assert_argument_error_number(1, 0) do
+        e.accept_name "extra arg"
+      end
+      assert_argument_error_number(0, 1) do
+        e.do_not_accept_name
+      end
+    end
+  end
+
+  def test_block_must_take_one_arg
+    assert_nothing_raised do
+      s = Respect::FakeNameProxy.new(@def_target).eval do |s, a|
+      end
+    end
+    assert_nothing_raised do
+      s = Respect::FakeNameProxy.new(@def_target).eval do
+      end
+    end
+  end
+
+  def test_handle_target_dynamic_method
+    # If the target accepts name, all arguments are always passed unchanged.
+    @evaluator.eval do |e|
+      assert_equal [:dynamic_method, [], nil], e.dynamic_method
+      assert_equal [:dynamic_method, [1, 2], nil], e.dynamic_method(1, 2)
+      assert_equal [:dynamic_method, [1, 2, 3], nil], e.dynamic_method(1, 2, 3)
+    end
+    # If the target does not accepts name, a fake name is always passed (we do not test whether the first
+    # parameters is a name since we do not have access to the parameters list).
+    @evaluator_no_name.eval do |e|
+      assert_equal [:dynamic_method, [nil], nil], e.dynamic_method
+      assert_equal [:dynamic_method, [nil, 1, 2], nil], e.dynamic_method(1, 2)
+      assert_equal [:dynamic_method, [nil, 1, 2, 3], nil], e.dynamic_method(1, 2, 3)
+    end
+  end
+
+  def test_can_access_target_ancestors_methods
+    @evaluator.eval do |e|
+      assert(e.target.class == e.class, "call to Object method")
+      assert(e.send(:String, :foo) == e.target.send(:String, :foo), "call to Kernel method")
+    end
+  end
+
+  def test_self_does_not_change_in_block
+    @evaluator.eval do
+      assert_kind_of(FakeNameProxyTest, self)
+    end
+  end
+
+  private
+
+  def assert_argument_error_number(actual, expected, &block)
+    begin
+      block.call
+      assert false
+    rescue ArgumentError => err
+      assert_match(/\(#{actual} for #{expected}\)/, err.message)
+    end
+  end
+end

data/test/float_schema_test.rb

@@ -0,0 +1,146 @@
+require "test_helper"
+
+class FloatSchemaTest < Test::Unit::TestCase
+  def test_expected_value_are_not_converted
+    s = Respect::FloatSchema.new(equal_to: "42.5")
+    assert_raise(Respect::ValidationError) do
+      s.validate(42.5)
+    end
+  end
+
+  def test_malformed_string_value_raise_exception
+    s = Respect::FloatSchema.new
+    [
+      "s42.5",
+      "4s2.5",
+      "42.5s",
+      "4-2.5",
+      "42.5-",
+      "-+42.5",
+      "+-42.5",
+    ].each do |test_value|
+      assert_raise(Respect::ValidationError) do
+        s.validate_type(test_value)
+      end
+    end
+  end
+
+  def test_string_value_get_converted
+    [
+      [ "-42.5",   -42.5 ],
+      [ "+42.54",   42.54 ],
+      [  "42.123",  42.123 ],
+    ].each do |test_data|
+      s = Respect::FloatSchema.new
+      assert_equal test_data[1], s.validate_type(test_data[0])
+      assert_nil s.sanitized_object
+      s.validate(test_data[0])
+      assert_equal test_data[1], s.sanitized_object
+    end
+  end
+
+  def test_greater_than_constraint_works
+    s = Respect::FloatSchema.new(greater_than: 0)
+    assert s.validate(42.5)
+    [ 0.0, -42.5 ].each do |test_value|
+      assert_raise(Respect::ValidationError) do
+        s.validate(test_value)
+      end
+    end
+  end
+
+  def test_greater_than_or_equal_to_constraint_works
+    s = Respect::FloatSchema.new(greater_than_or_equal_to: 0)
+    assert s.validate(42.5)
+    assert s.validate(0.0)
+    assert_raise(Respect::ValidationError) do
+      s.validate(-42.5)
+    end
+  end
+
+  def test_less_than_constraint_works
+    s = Respect::FloatSchema.new(less_than: 0)
+    assert s.validate(-1.5)
+    [ 0.0, 1.5 ].each do |test_value|
+      assert_raise(Respect::ValidationError) do
+        s.validate(test_value)
+      end
+    end
+  end
+
+  def test_less_than_or_equal_to_constraint_works
+    s = Respect::FloatSchema.new(less_than_or_equal_to: 0)
+    assert s.validate(-1.5)
+    assert s.validate(0.0)
+    assert_raise(Respect::ValidationError) do
+      s.validate(1.5)
+    end
+  end
+
+  def test_float_value_is_in_set
+    s = Respect::FloatSchema.new(in: [42.5, 51.5])
+    assert_schema_validate s, 42.5
+    assert_schema_validate s, 51.5
+    assert_schema_invalidate s, 1664.5
+  end
+
+  def test_float_value_is_in_range
+    s = Respect::FloatSchema.new(in: 1.5..4.5)
+    assert_schema_invalidate s, 0.0
+    assert_schema_invalidate s, 1.4
+    assert_schema_validate s, 1.5
+    assert_schema_validate s, 2.0
+    assert_schema_validate s, 3.0
+    assert_schema_validate s, 4.0
+    assert_schema_validate s, 4.5
+    assert_schema_invalidate s, 4.6
+    assert_schema_invalidate s, 5.0
+
+    s = Respect::FloatSchema.new(in: 1.5...4.5)
+    assert_schema_invalidate s, 0.0
+    assert_schema_invalidate s, 1.4
+    assert_schema_validate s, 1.5
+    assert_schema_validate s, 2.0
+    assert_schema_validate s, 3.0
+    assert_schema_validate s, 4.0
+    assert_schema_invalidate s, 4.5
+    assert_schema_invalidate s, 4.6
+    assert_schema_invalidate s, 5.0
+  end
+
+  def test_float_accept_equal_to_constraint
+    s = Respect::FloatSchema.new(equal_to: 41.5)
+    assert_schema_validate s, 41.5
+    assert_schema_invalidate s, 41.55
+  end
+
+  def test_failed_validation_reset_sanitized_object
+    s = Respect::FloatSchema.new equal_to: 42.5
+    assert_schema_validate(s, 42.5)
+    assert_equal(42.5, s.sanitized_object)
+    assert_schema_invalidate(s, "wrong")
+    assert_equal(nil, s.sanitized_object)
+  end
+
+  def test_allow_nil
+    s = Respect::FloatSchema.new(allow_nil: true)
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, 42.5
+    assert_equal(42.5, s.sanitized_object)
+    assert_schema_validate s, "42.5"
+    assert_equal(42.5, s.sanitized_object)
+  end
+
+  def test_disallow_nil
+    s = Respect::FloatSchema.new
+    assert !s.allow_nil?
+    exception = assert_exception(Respect::ValidationError) { s.validate(nil) }
+    assert_match exception.message, /\bFloatSchema\b/
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, 42.5
+    assert_equal(42.5, s.sanitized_object)
+    assert_schema_validate s, "42.5"
+    assert_equal(42.5, s.sanitized_object)
+  end
+end

data/test/format_validator_test.rb

@@ -0,0 +1,224 @@
+require "test_helper"
+
+class FormatValidatorTest < Test::Unit::TestCase
+
+  def setup
+    @valid_ipv4_addr = [
+      "0.0.0.0",
+      "255.255.255.255",
+      "1.1.1.1",
+      "11.1.1.1",
+      "11.1.1.1",
+      "1.1.1.1",
+      "1.11.1.1",
+      "1.111.1.1",
+      "1.1.1.1",
+      "1.1.11.1",
+      "1.1.111.1",
+      "1.1.1.1",
+      "1.1.1.11",
+      "1.1.1.111",
+    ]
+    @invalid_ipv4_addr = [
+      "a1.1.1.1",
+      "1.1.1.1b",
+      "260.0.0.0",
+      "0.260.0.0",
+      "0.0.260.0",
+      "0.0.0.260",
+      "0.0.0.0.0",
+    ]
+    @valid_ipv6_addr = [
+      "1080:0:0:0:8:800:200C:417A",
+      "FF01:0:0:0:0:0:0:101",
+      "0:0:0:0:0:0:0:1",
+      "0:0:0:0:0:0:0:0",
+    ]
+    @invalid_ipv6_addr = [
+      "z1080:0:0:0:8:800:200C:417A",
+      "FF01:0:0:0:0:0:0:101z",
+      "0:0:0:0",
+      "0:0:0:0:0:0:11111:0",
+    ]
+  end
+
+  def test_ipv4_addr_validator
+    # Valid IPv4 sample data.
+    @valid_ipv4_addr.each_with_index do |test_data, i|
+      assert_nothing_raised("validate #{i}") do
+        Respect::FormatValidator.new(:ipv4_addr).validate(test_data)
+      end
+    end
+    # Invalid IPv4 sample data.
+    @invalid_ipv4_addr.each_with_index do |test_data, i|
+      assert_raises(Respect::ValidationError, "validate #{i}") do
+        Respect::FormatValidator.new(:ipv4_addr).validate(test_data)
+      end
+    end
+  end
+
+  def test_ipv4_addr_say_is_not_ipv4
+    begin
+      Respect::FormatValidator.new(:ipv4_addr).validate("0.333.0.0")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\bIPv4\b/, e.message)
+      assert_match(/\b0.333.0.0\b/, e.message)
+    end
+  end
+
+  def test_ipv4_addr_mention_wrong_value_in_error
+    begin
+      Respect::FormatValidator.new(:ipv4_addr).validate("invalid")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\binvalid\b/, e.message)
+    end
+  end
+
+  def test_phone_number_validator
+    # Valid phone number sample data.
+    [
+      "+112",
+      "00112",
+      "+1212",
+      "001212",
+      "1",
+      "123456789",
+    ].each_with_index do |test_data, i|
+      assert_nothing_raised("validate #{i}") do
+        Respect::FormatValidator.new(:phone_number).validate(test_data)
+      end
+    end
+    # Invalid phone number sample data.
+    [
+      "-112",
+      "00112a",
+      "a+1212",
+      "00d1212",
+      "1-",
+      "12 34 56 78 9",
+    ].each_with_index do |test_data, i|
+      assert_raises(Respect::ValidationError, "validate #{i}") do
+        Respect::FormatValidator.new(:phone_number).validate(test_data)
+      end
+    end
+  end
+
+  def test_phone_number_mention_wrong_value_in_error
+    begin
+      Respect::FormatValidator.new(:phone_number).validate("invalid00phone00number")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\binvalid00phone00number\b/, e.message)
+    end
+  end
+
+  def test_ipv6_addr_validator
+    # Valid IPv6 sample data.
+    @valid_ipv6_addr.each_with_index do |test_data, i|
+      assert_nothing_raised("validate #{i}") do
+        Respect::FormatValidator.new(:ipv6_addr).validate(test_data)
+      end
+    end
+    # Invalid IPV6 sample data.
+    @invalid_ipv6_addr.each_with_index do |test_data, i|
+      assert_raises(Respect::ValidationError, "validate #{i}") do
+        Respect::FormatValidator.new(:ipv6_addr).validate(test_data)
+      end
+    end
+  end
+
+  def test_ipv6_addr_say_it_is_not_ipv6
+    begin
+      Respect::FormatValidator.new(:ipv6_addr).validate("0.333.0.0")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\bIPv6\b/, e.message)
+      assert_match(/\b0.333.0.0\b/, e.message)
+    end
+  end
+
+  def test_ipv6_addr_mention_wrong_value_in_error
+    begin
+      Respect::FormatValidator.new(:ipv6_addr).validate("invalid_ipaddr")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\binvalid_ipaddr\b/, e.message)
+    end
+  end
+
+  def test_ip_addr_validator
+    # Valid IP sample data.
+    (@valid_ipv4_addr + @valid_ipv6_addr).each_with_index do |test_data, i|
+      assert_nothing_raised("validate #{i}") do
+        Respect::FormatValidator.new(:ip_addr).validate(test_data)
+      end
+    end
+    # Invalid IP sample data.
+    (@invalid_ipv4_addr + @invalid_ipv6_addr).each_with_index do |test_data, i|
+      assert_raises(Respect::ValidationError, "validate #{i}") do
+        Respect::FormatValidator.new(:ip_addr).validate(test_data)
+      end
+    end
+  end
+
+  def test_ip_mention_wrong_value_in_error
+    begin
+      Respect::FormatValidator.new(:ip_addr).validate("invalid_ipaddr")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\binvalid_ipaddr\b/, e.message)
+    end
+  end
+
+  def test_hostname_addr_validator
+    # Valid hostname sample data.
+    [
+      "a.b.c.d",
+      "aa.bb.cc.dd",
+      "aaa.bbb.ccc.ddd",
+      "a",
+      "abcdefghijklmnopqrstuvwxyz-0123456789",
+      "abcdefghijklmnopqrstuvwxyz-0123456789.abcdefghijklmnopqrstuvwxyz-0123456789",
+      "A.B.C.D",
+    ].each_with_index do |test_data, i|
+      assert_nothing_raised("validate #{i}") do
+        Respect::FormatValidator.new(:hostname).validate(test_data)
+      end
+    end
+    # Invalid hostname sample data.
+    [
+      "-a.b.c.d",
+      "1a.b.c.d",
+      "a_b",
+    ].each_with_index do |test_data, i|
+      assert_raises(Respect::ValidationError, "validate #{i}") do
+        Respect::FormatValidator.new(:hostname).validate(test_data)
+      end
+    end
+  end
+
+  def test_hostname_say_which_part_is_wrong
+    begin
+      invalid_part = "b" * 100
+      invalid_hostname = "a.#{invalid_part}.c.d"
+      Respect::FormatValidator.new(:hostname).validate(invalid_hostname)
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\b#{invalid_part}\b/, e.message)
+      assert_match(/\b1st\b/, e.message)
+      assert_match(/\b#{invalid_hostname}\b/, e.message)
+    end
+  end
+
+  def test_ipv4_addr_mention_wrong_value_in_error
+    begin
+      Respect::FormatValidator.new(:ipv4_addr).validate("invalid_hostname")
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_match(/\binvalid_hostname\b/, e.message)
+    end
+  end
+
+end