respect 0.1.0

data/test/schema_test.rb

@@ -0,0 +1,290 @@
+require "test_helper"
+
+class SchemaTest < Test::Unit::TestCase
+  def test_validate_value_return_true_on_success
+    s = Respect::HashSchema.define do |s|
+      s.string "test", equal_to: "value"
+    end
+    assert s.validate({ "test" => "value" })
+  end
+
+  def test_no_exception_raised_for_invalid_constraint
+    s = Respect::HashSchema.define do |s|
+      s.string "test", invalid_constraint: "value"
+    end
+    assert_nothing_raised do
+      assert s.validate({ "test" => "value" })
+    end
+  end
+
+  def test_access_to_sanitized_value
+    s = Respect::IntegerSchema.new(equal_to: 42)
+    doc = "42"
+    assert s.validate(doc)
+    assert_equal 42, s.sanitized_object
+  end
+
+  def test_validate_query_does_not_raise_exception_when_invalid
+    s = Respect::HashSchema.define do |s|
+      s.string "test", equal_to: "value"
+    end
+    assert_schema_validate s, { "test" => "value" }
+    assert_schema_invalidate s, { "test" => "invalid" }
+  end
+
+  def test_non_collection_schema_validation_error_have_context
+    s = Respect::Schema.define do |s|
+      s.string equal_to: "value"
+    end
+    assert_schema_invalidate s, "invalid"
+    assert_equal 1, s.last_error.context.size
+    assert (s.last_error.message == s.last_error.context.first)
+  end
+
+  def test_hash_schema_validation_error_have_context
+    s = Respect::HashSchema.define do |s|
+      s.string "test", equal_to: "value"
+    end
+    assert_schema_invalidate s, { "test" => "invalid" }
+    assert_equal 2, s.last_error.context.size
+    assert_hash_context_error_message("test", s.last_error.context.last)
+  end
+
+  def test_array_schema_validation_error_have_context
+    s = Respect::ArraySchema.define do |s|
+      s.numeric
+    end
+    assert_schema_invalidate s, [1, "invalid", 3]
+    assert_equal 2, s.last_error.context.size
+    assert_array_context_error_message(1, s.last_error.context.last)
+  end
+
+  def test_error_context_can_be_nested
+    s = Respect::HashSchema.define do |s|
+      s.hash "level_1" do |s|
+        s.array "level_2" do |s|
+          s.hash do |s|
+            s.numeric "level_4", equal_to: 51
+          end
+        end
+      end
+    end
+    doc = {
+      "level_1" => {
+        "level_2" => [
+          { "level_4" => 42 }
+        ]
+      }
+    }
+    assert_schema_invalidate s, doc
+    assert_equal 5, s.last_error.context.size
+    assert_hash_context_error_message("level_4", s.last_error.context[1])
+    assert_array_context_error_message("0", s.last_error.context[2])
+    assert_hash_context_error_message("level_2", s.last_error.context[3])
+    assert_hash_context_error_message("level_1", s.last_error.context[4])
+  end
+
+  def test_schema_to_s_as_dsl
+    s = Respect::HashSchema.new
+    d = Respect::DslDumper.new(s)
+    Respect::DslDumper.expects(:new).with(s).returns(d)
+    d.stubs(:dump).at_least_once
+    s.to_s
+  end
+
+  def test_schema_to_json_org3
+    h = {}
+    h.stubs(:to_json).returns('json string').at_least_once
+
+    s = Respect::HashSchema.new
+    s.stubs(:to_h).with(:org3).returns(h).at_least_once
+
+    assert_equal("json string", s.to_json(:org3))
+  end
+
+  def test_schema_to_h_as_org3
+    s = Respect::HashSchema.new
+    d = Respect::Org3Dumper.new(s)
+    Respect::Org3Dumper.expects(:new).with(s).returns(d)
+    d.stubs(:dump).returns("json hash").at_least_once
+    assert_equal("json hash",  s.to_h(:org3))
+  end
+
+  def test_def_class_name
+    assert_equal "Respect::SchemaDef", Respect::Schema.def_class_name
+    assert_equal "Respect::ArrayDef", Respect::ArraySchema.def_class_name
+    assert_equal "Respect::HashDef", Respect::HashSchema.def_class_name
+    assert_equal "Respect::StringDef", Respect::StringSchema.def_class_name
+  end
+
+  def test_def_class
+    assert_equal Respect::SchemaDef, Respect::Schema.def_class
+    assert_equal Respect::ArrayDef, Respect::ArraySchema.def_class
+    assert_equal Respect::HashDef, Respect::HashSchema.def_class
+    assert_equal nil, Respect::StringSchema.def_class
+  end
+
+  def test_statement_name
+    assert_equal "string", Respect::StringSchema.statement_name
+    assert_equal "integer", Respect::IntegerSchema.statement_name
+    assert_equal "schema", Respect::Schema.statement_name
+    assert_equal "circle", Respect::CircleSchema.statement_name
+    assert_equal "point", Respect::PointSchema.statement_name
+  end
+
+  def test_in_place_validation_always_return_boolean
+    s = Respect::Schema.define do |s|
+      s.boolean
+    end
+    assert_equal true, s.validate!(false)
+    assert_equal true, s.validate!(true)
+    assert_equal false, s.validate!(nil)
+  end
+
+  def test_sanitize_always_return_new_object
+    s = Respect::Schema.define do |s|
+      s.boolean
+    end
+    assert_equal false, s.sanitize!(false)
+    assert_equal true, s.sanitize!(true)
+    assert_raise(Respect::ValidationError) do
+      s.sanitize!(nil)
+    end
+  end
+
+  def test_schema_accept_doc_option
+    s = Respect::IntegerSchema.new(doc: "Hey!")
+    assert_equal "Hey!", s.doc
+    assert_equal "Hey!", s.options[:doc]
+  end
+
+  def test_duplicata_are_equal
+    s1 = Respect::IntegerSchema.new
+    assert_equal s1, s1.dup
+  end
+
+  def test_schema_differs_from_options
+    s1 = Respect::IntegerSchema.new(required: true)
+    s2 = Respect::IntegerSchema.new(required: false)
+    assert(s1 != s2)
+  end
+
+  def test_schema_differs_from_doc
+    s1 = Respect::Schema.define do |s|
+      s.doc "hey"
+      s.integer
+    end
+    s2 = Respect::Schema.define do |s|
+      s.doc "ho"
+      s.integer
+    end
+    assert(s1 != s2)
+  end
+
+  def test_schema_differs_from_type
+    s1 = Respect::IntegerSchema.new
+    s2 = Respect::StringSchema.new
+    assert(s1 != s2)
+  end
+
+  def test_schema_differs_from_validator
+    s1 = Respect::IntegerSchema.new(equal_to: 42)
+    s2 = Respect::IntegerSchema.new(equal_to: 51)
+    assert(s1 != s2)
+  end
+
+  def test_schema_dont_differs_from_sanitized_object
+    s1 = Respect::IntegerSchema.new
+    s1.send(:sanitized_object=, 42)
+    s2 = Respect::IntegerSchema.new
+    s2.send(:sanitized_object=, 51)
+    assert(s1 == s2)
+  end
+
+  def test_dup_duplicate_options
+    s1 = Respect::IntegerSchema.define equal_to: 42
+    s2 = s1.dup
+    assert(s2.object_id != s1.object_id)
+    assert_equal(42, s2.options[:equal_to])
+  end
+
+  def test_validate_query_returns_true_when_no_error
+    s = Respect::Schema.send(:new)
+    doc = {}
+    s.stubs(:validate).with(doc).returns(nil).once
+    assert_equal true, s.validate?(doc)
+  end
+
+  def test_validate_query_returns_false_on_error_and_store_last_error
+    s = Respect::Schema.send(:new)
+    doc = {}
+    error = Respect::ValidationError.new("message")
+    s.stubs(:validate).with(doc).raises(error).once
+    assert_equal false, s.validate?(doc)
+    assert_equal error, s.last_error
+  end
+
+  def test_validate_shebang_returns_true_on_success_and_sanitize
+    s = Respect::Schema.send(:new)
+    doc = {}
+    s.stubs(:validate?).with(doc).returns(true).once
+    s.stubs(:sanitize_object!).with(doc).once
+    assert_equal true, s.validate!(doc)
+  end
+
+  def test_validate_shebang_returns_false_on_failure
+    s = Respect::Schema.send(:new)
+    doc = {}
+    s.stubs(:validate?).with(doc).returns(false).once
+    assert_equal false, s.validate!(doc)
+  end
+
+  def test_sanitize_shebang_raises_exception_on_error
+    s = Respect::Schema.send(:new)
+    doc = {}
+    error = Respect::ValidationError.new("message")
+    s.stubs(:validate).with(doc).raises(error).once
+    begin
+      s.sanitize!(doc)
+      assert false, "nothing raised"
+    rescue Respect::ValidationError => e
+      assert_equal error, e
+    end
+  end
+
+  def test_sanitize_shebang_sanitize_on_success
+    s = Respect::Schema.send(:new)
+    doc = {}
+    s.stubs(:validate).with(doc).once
+    result = Object.new
+    s.stubs(:sanitize_object!).with(doc).returns(result).once
+    assert_equal result.object_id, s.sanitize!(doc).object_id
+  end
+
+  def test_sanitize_doc_shebang
+    s = Respect::Schema.send(:new)
+    doc = {}
+    sanitized_object = {}
+    s.stubs(:sanitized_object).with().returns(sanitized_object).once
+    result = Object.new
+    Respect.stubs(:sanitize_object!).with(doc, sanitized_object).returns(result).once
+    assert_equal result.object_id, s.sanitize_object!(doc).object_id
+  end
+
+  private
+
+  def assert_hash_context_error_message(prop_name, message)
+    [ /\bin\b/, /\bhash\b/, /\bproperty\b/, /\b#{prop_name}\b/ ].each do |rx|
+      assert(rx =~ message,
+        "error message '#{message}' does not match #{rx}")
+    end
+  end
+
+  def assert_array_context_error_message(index, message)
+    [ /\bin\b/, /\barray\b/, /\bitem\b/, /\b#{index}/ ].each do |rx|
+      assert(rx =~ message,
+        "error message '#{message}' does not match #{rx}")
+    end
+  end
+
+end

data/test/string_schema_test.rb

@@ -0,0 +1,209 @@
+require "test_helper"
+
+class StringSchemaTest < Test::Unit::TestCase
+  def test_expected_value_are_not_converted
+    s = Respect::StringSchema.new(equal_to: 42)
+    assert_raise(Respect::ValidationError) do
+      assert s.validate("42")
+    end
+  end
+
+  def test_non_string_value_get_converted
+    s = Respect::StringSchema.new
+    assert_equal "42", s.validate_type(42)
+    assert_nil s.sanitized_object
+    s.validate(42)
+    assert_equal "42", s.sanitized_object
+  end
+
+  def test_string_property_has_no_greater_than_constraint
+    s = Respect::StringSchema.new(greater_than: 0)
+    # Using an integer constraints with a string lead to
+    # unexpected result.
+    assert_raises(ArgumentError) do
+      s.validate(-1)
+    end
+  end
+
+  def test_string_accept_options_mixed_with_constraints
+    s = Respect::StringSchema.new(equal_to: "42", required: false)
+    assert_equal false, s.options[:required]
+    assert_equal "42", s.options[:equal_to]
+    assert s.validate("42")
+  end
+
+  def test_string_value_is_in_set
+    s = Respect::StringSchema.new(in: ["foo", "bar"])
+    assert_schema_validate s, "foo"
+    assert_schema_validate s, "bar"
+    assert_schema_invalidate s, "not included"
+  end
+
+  def test_string_value_match_pattern
+    s = Respect::StringSchema.new(match: /foo*/)
+    assert_schema_validate s, "_foo_"
+    assert_schema_validate s, "fo"
+    assert_schema_validate s, "fol"
+    assert_schema_validate s, "foooooooooooo"
+    assert_schema_invalidate s, "f_b"
+  end
+
+  def test_string_value_has_min_length
+    s = Respect::StringSchema.new(min_length: 2)
+    assert_schema_validate s, "foo"
+    assert_schema_validate s, "fo"
+    assert_schema_invalidate s, "f"
+  end
+
+  def test_string_value_has_max_length
+    s = Respect::StringSchema.new(max_length: 2)
+    assert_schema_invalidate s, "foo"
+    assert_schema_validate s, "fo"
+    assert_schema_validate s, "f"
+  end
+
+  def test_string_accept_equal_to_constraint
+    s = Respect::StringSchema.new(equal_to: "41")
+    assert_schema_validate s, "41"
+    assert_schema_invalidate s, "52"
+  end
+
+  def test_string_validate_email_format
+    [
+      [ "foo",            false, ],
+      [ "foo@bar",        true,  ],
+      [ "foo@example.om", true,  ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:email, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_uri_format
+    [
+      [ "<>",             false, ],
+      [ "http://foo.com", true,  ],
+      [ "foo@example.om", true,  ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:uri, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_regexp_format
+    [
+      [ "foo(",      false, ],
+      [ "^foo$",     true,  ],
+      [ "^foo|bar$", true,  ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:regexp, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_datetime_format
+    [
+      [ "invalid",                   false, ],
+      [ "2013-12-01T00:00:00+00:00", true,  ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:datetime, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_ipv4_addr_format
+    [
+      [ "192.168.0.1", true, ],
+      [ "invalid",     false, ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:ipv4_addr, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_phone_number_format
+    [
+      [ "+3360123456789", true, ],
+      [ "invalid",        false, ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:phone_number, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_ipv6_addr_format
+    [
+      [ "3ffe:505:2::1", true, ],
+      [ "invalid",        false, ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:ipv6_addr, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_ip_addr_format
+    [
+      [ "192.168.0.1",   true, ],
+      [ "3ffe:505:2::1", true, ],
+      [ "invalid",       false, ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:ip_addr, data[1], data[0])
+    end
+  end
+
+  def test_string_validate_hostname_format
+    [
+      [ "a.b.c.d",  true, ],
+      [ "0invalid", false, ],
+    ].each_with_index do |data, i|
+      assert_validate_string_format(:hostname, data[1], data[0])
+    end
+  end
+
+  def test_failed_validation_reset_sanitized_object
+    s = Respect::StringSchema.define equal_to: "42"
+    assert_schema_validate(s, "42")
+    assert_equal("42", s.sanitized_object)
+    assert_schema_invalidate(s, "51")
+    assert_equal(nil, s.sanitized_object)
+  end
+
+  def test_allow_nil
+    s = Respect::StringSchema.new(allow_nil: true)
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, "42"
+    assert_equal("42", s.sanitized_object)
+    assert_schema_validate s, 42
+    assert_equal("42", s.sanitized_object)
+  end
+
+  def test_disallow_nil
+    s = Respect::StringSchema.new
+    assert !s.allow_nil?
+    exception = assert_exception(Respect::ValidationError) { s.validate(nil) }
+    assert_match exception.message, /\bStringSchema\b/
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, "42"
+    assert_equal("42", s.sanitized_object)
+    assert_schema_validate s, 42
+    assert_equal("42", s.sanitized_object)
+  end
+
+  def test_allow_nil_with_constraint
+    s = Respect::StringSchema.new(allow_nil: true, equal_to: "42")
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, "42"
+    assert_equal("42", s.sanitized_object)
+    assert_schema_invalidate s, "51"
+    assert_equal(nil, s.sanitized_object)
+  end
+
+  private
+
+  def assert_validate_string_format(format, result, doc)
+    s = Respect::StringSchema.new(format: format)
+    assert_nil s.sanitized_object
+    assert_schema_validation_is result, s, doc, "validate '#{doc}'"
+    if result
+      assert s.sanitized_object.is_a?(String), "is a String for '#{doc}'"
+      assert_equal doc, s.sanitized_object, "sanitize '#{doc}'"
+    else
+      assert_nil s.sanitized_object
+    end
+  end
+end