respect 0.1.0

data/test/null_schema_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class NullSchemaTest < Test::Unit::TestCase
+  def test_null_schema_validate_format
+    # Malformed document.
+    [
+      [ "42", false, "integer in string" ],
+      [ { "test" => 42 }, false, "hash" ],
+      [ "true", false, "true in string" ],
+      [ "false", false, "false in string" ],
+      [ "string", false, "string" ],
+      [ "nil", false, "nil in string" ],
+      [ nil, true, "nil" ],
+      [ "null", true, "null in string" ],
+    ].each do |data|
+      s = Respect::NullSchema.new
+      assert_nil s.sanitized_object
+      validated = s.validate?(data[0])
+      assert_equal data[1], validated, data[2]
+      if validated
+        assert_nil s.sanitized_object, data[2]
+      end
+    end
+  end
+
+  def test_failed_validation_reset_sanitized_object
+    s = Respect::NullSchema.new
+    assert_schema_validate(s, nil)
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_invalidate(s, 42)
+    assert_equal(nil, s.sanitized_object)
+  end
+
+  def test_allow_nil
+    s = Respect::NullSchema.new(allow_nil: true)
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+  end
+
+  def test_disallow_nil
+    s = Respect::NullSchema.new
+    assert !s.allow_nil?
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+  end
+end

data/test/numeric_schema_test.rb

@@ -0,0 +1,294 @@
+require "test_helper"
+
+class NumericSchemaTest < Test::Unit::TestCase
+  def test_expected_value_are_not_converted
+    s = Respect::NumericSchema.new(equal_to: "42.5")
+    assert_raise(Respect::ValidationError) do
+      s.validate(42.5)
+    end
+    s = Respect::NumericSchema.new(equal_to: "42")
+    assert_raise(Respect::ValidationError) do
+      s.validate(42)
+    end
+  end
+
+  def test_malformed_string_value_raise_exception
+    s = Respect::NumericSchema.new
+    [
+      "s42.5",
+      "4s2.5",
+      "42.5s",
+      "4-2.5",
+      "42.5-",
+      "-+42.5",
+      "+-42.5",
+      "s42",
+      "4s2",
+      "42s",
+      "4-2",
+      "42-",
+      "-+42",
+      "+-42",
+    ].each do |test_value|
+      assert_schema_invalidate s, test_value, "#{test_value} is invalid"
+    end
+  end
+
+  def test_string_value_get_converted
+    [
+      [ "-42.5",   -42.5 ],
+      [ "+42.54",   42.54 ],
+      [  "42.123",  42.123 ],
+      [ "-42", -42 ],
+      [ "+42",  42 ],
+      [  "42",  42 ],
+    ].each do |test_data|
+      s = Respect::NumericSchema.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::NumericSchema.new(greater_than: 0)
+    assert s.validate(42.5)
+    assert s.validate(42)
+    [ 0, -42, 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::NumericSchema.new(greater_than_or_equal_to: 0)
+    assert s.validate(42.5)
+    assert s.validate(0.0)
+    assert s.validate(42)
+    assert s.validate(0)
+    [ -42, -42.5 ].each do |test_value|
+      assert_raise(Respect::ValidationError) do
+        s.validate(test_value)
+      end
+    end
+  end
+
+  def test_less_than_constraint_works
+    s = Respect::NumericSchema.new(less_than: 0)
+    assert s.validate(-1.5)
+    assert s.validate(-1)
+    [ 0.0, 1.5, 0, 1 ].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::NumericSchema.new(less_than_or_equal_to: 0)
+    assert s.validate(-1.5)
+    assert s.validate(0.0)
+    assert s.validate(-1)
+    assert s.validate(0)
+    [ 1.5, 1 ].each do |test_value|
+      assert_raise(Respect::ValidationError) do
+        s.validate(test_value)
+      end
+    end
+  end
+
+  def test_schema_definition_accept_numeric
+    s = Respect::Schema.define do |s|
+      s.numeric equal_to: 1.5
+    end
+    assert_schema_validate s, "1.5"
+    assert_schema_validate s, 1.5
+
+    s = Respect::Schema.define do |s|
+      s.numeric equal_to: 1
+    end
+    assert_schema_validate s, "1"
+    assert_schema_validate s, 1
+  end
+
+  def test_schema_definition_accept_numeric_with_no_option
+    s = Respect::Schema.define do |s|
+      s.numeric
+    end
+    assert_schema_validate s, 42
+    assert_schema_validate s, 42.5
+  end
+
+  def test_hash_schema_definition_accept_numeric
+    s = Respect::HashSchema.define do |s|
+      s.numeric "test", equal_to: 1.5
+      s.extra do |s|
+        s.numeric "opt", equal_to: 4
+      end
+    end
+    assert_schema_validate s, { "test" => "1.5", "opt" => "4" }
+    assert_schema_validate s, { "test" => 1.5, "opt" => 4 }
+  end
+
+  def test_array_schema_definition_accept_numeric
+    s = Respect::ArraySchema.define do |s|
+      s.numeric equal_to: 1.5
+    end
+    assert_schema_validate s, ["1.5"]
+    assert_schema_validate s, [1.5]
+
+    s = Respect::ArraySchema.define do |s|
+      s.numeric equal_to: 1
+    end
+    assert_schema_validate s, ["1"]
+    assert_schema_validate s, [1]
+  end
+
+  def test_numeric_is_in_set
+    s = Respect::NumericSchema.new(in: [42.5, 51.5, 42, 51])
+    assert_schema_validate s, 42.5
+    assert_schema_validate s, 51.5
+    assert_schema_validate s, 42
+    assert_schema_validate s, 51
+    assert_schema_invalidate s, 1664.5
+    assert_schema_invalidate s, 1664
+  end
+
+  def test_numeric_value_is_in_range
+    s = Respect::NumericSchema.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::NumericSchema.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
+
+    s = Respect::NumericSchema.new(in: 1..4)
+    assert_schema_invalidate s, 0
+    assert_schema_validate s, 1
+    assert_schema_validate s, 2
+    assert_schema_validate s, 3
+    assert_schema_validate s, 4
+    assert_schema_invalidate s, 5
+
+    s = Respect::NumericSchema.new(in: 1...4)
+    assert_schema_invalidate s, 0
+    assert_schema_validate s, 1
+    assert_schema_validate s, 2
+    assert_schema_validate s, 3
+    assert_schema_invalidate s, 4
+    assert_schema_invalidate s, 5
+  end
+
+  def test_numeric_accept_equal_to_constraint
+    s = Respect::NumericSchema.new(equal_to: 41)
+    assert_schema_validate s, 41
+    assert_schema_validate s, 41.0
+    assert_schema_validate s, "41"
+    assert_schema_validate s, "41.0"
+    assert_schema_invalidate s, 41.55
+    assert_schema_invalidate s, 42
+  end
+
+  def test_divisible_by_and_multiple_of_option_works
+    [ :divisible_by, :multiple_of ].each do |opt|
+      # Works with integer
+      s = Respect::NumericSchema.new(opt => 2)
+      assert_schema_validate s, 4, "validate #{opt}"
+      assert_schema_validate s, 2, "validate #{opt}"
+      assert_schema_invalidate s, 1, "invalidate #{opt}"
+      assert_schema_invalidate s, 3, "invalidate #{opt}"
+      # Works with float
+      s = Respect::NumericSchema.new(opt => 2.1)
+      assert_schema_validate s, 4.2, "validate #{opt}"
+      assert_schema_validate s, 2.1, "validate #{opt}"
+      assert_schema_invalidate s, 1.4, "invalidate #{opt}"
+      assert_schema_invalidate s, 3.4, "invalidate #{opt}"
+    end
+  end
+
+  def test_divisible_by_option_mention_operands_in_error
+    begin
+      Respect::NumericSchema.new(divisible_by: 2).validate(3)
+      assert false
+    rescue Respect::ValidationError => e
+      assert_match(/\b3\b/, e.message)
+      assert_match(/\b2\b/, e.message)
+      assert_match(/\bdivisible by\b/, e.message)
+    end
+  end
+
+  def test_multiple_of_option_mention_operands_in_error
+    begin
+      Respect::NumericSchema.new(multiple_of: 2).validate(3)
+      assert false
+    rescue Respect::ValidationError => e
+      assert_match(/\b3\b/, e.message)
+      assert_match(/\b2\b/, e.message)
+      assert_match(/\ba multiple of\b/, e.message)
+    end
+  end
+
+  def test_failed_validation_reset_sanitized_object
+    s = Respect::NumericSchema.new equal_to: 42
+    assert_schema_validate(s, 42)
+    assert_equal(42, s.sanitized_object)
+    assert_schema_invalidate(s, "wrong")
+    assert_equal(nil, s.sanitized_object)
+  end
+
+  def test_allow_nil
+    s = Respect::NumericSchema.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::NumericSchema.new
+    assert !s.allow_nil?
+    exception = assert_exception(Respect::ValidationError) { s.validate(nil) }
+    assert_match exception.message, /\bNumericSchema\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::NumericSchema.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)
+    assert_schema_validate s, "42"
+    assert_equal(42, s.sanitized_object)
+  end
+
+  def test_allow_nil_with_wrong_constraint_still_invalidate
+    s = Respect::NumericSchema.new(allow_nil: true, equal_to: "42")
+    assert_schema_invalidate s, "42"
+  end
+end

data/test/org3_dumper_test.rb

@@ -0,0 +1,784 @@
+require "test_helper"
+
+class Org3DumperTest < Test::Unit::TestCase
+  def test_dump_basic_types_statements_with_no_options
+    [
+      :integer,
+      :string,
+      :any,
+      :boolean,
+      :null,
+    ].each do |statement|
+      s = Respect::Schema.define do |s|
+        s.__send__(statement)
+      end
+      a = Respect::Org3Dumper.new(s).dump
+      e = {
+        "type" => statement.to_s,
+      }
+      assert_equal e, a, "dump statement #{statement}"
+    end
+  end
+
+  def test_numeric_and_float_schema_are_number_type
+    {
+      :NumericSchema => "number",
+      :FloatSchema => "number",
+    }.each do |schema_class, type|
+      s = Respect.const_get(schema_class).new
+      a = Respect::Org3Dumper.new(s).dump
+      e = { "type" => type }
+      assert_equal e, a, "dump schema #{schema_class}"
+    end
+  end
+
+  def test_dump_extended_simple_schema
+    {
+      :URISchema => "uri",
+      :RegexpSchema => "regex",
+      :DatetimeSchema => "date-time",
+      :Ipv4AddrSchema => "ip-address",
+      :Ipv6AddrSchema => "ipv6",
+    }.each do |schema_class, format|
+      s = Respect.const_get(schema_class).new
+      a = Respect::Org3Dumper.new(s).dump
+      e = { "type" => "string", "format" => format}
+      assert_equal e, a, "dump schema #{schema_class}"
+    end
+  end
+
+  # TODO(Nicolas Despres): Test IPAddrSchema warn that it can not be dumped.
+  # TODO(Nicolas Despres): Test UTCTimeSchema warn that it can not be dumped.
+
+  def test_dump_helper_statement
+    {
+      :phone_number => "phone",
+      :hostname => "host-name",
+      :email => "email",
+    }.each do |statement, format|
+      s = Respect::Schema.define do |s|
+        s.__send__(statement)
+      end
+      a = Respect::Org3Dumper.new(s).dump
+      e = {
+        "type" => "string",
+        "format" => format,
+      }
+      assert_equal e, a, "dump statement #{statement}"
+    end
+  end
+
+  def test_dump_hash_properties
+    s = Respect::HashSchema.define do |s|
+      s.integer "i"
+      s.string "s"
+      s.float "f"
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "i" => {
+          "type" => "integer",
+          "required" => true,
+        },
+        "s" => {
+          "type" => "string",
+          "required" => true,
+        },
+        "f" => {
+          "type" => "number",
+          "required" => true,
+        },
+      }
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_hash_optional_properties
+    s = Respect::HashSchema.define do |s|
+      s.integer "i"
+      s.string "s"
+      s.extra do |s|
+        s.string "o_s"
+        s.float "o_f"
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "i" => {
+          "type" => "integer",
+          "required" => true,
+        },
+        "s" => {
+          "type" => "string",
+          "required" => true,
+        },
+      },
+      "additionalProperties" => {
+        "o_s" => { "type" => "string" },
+        "o_f" => { "type" => "number" },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_hash_pattern_properties
+    s = Respect::HashSchema.define do |s|
+      s.integer "i"
+      s.string /s.*t/
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "i" => {
+          "type" => "integer",
+          "required" => true,
+        },
+      },
+      "patternProperties" => {
+        "s.*t" => {
+          "type" => "string",
+          "required" => true,
+        },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_hash
+    s = Respect::HashSchema.define do |s|
+      s.hash "o1" do |s|
+        s.hash "o2" do |s|
+          s.hash "o3" do |s|
+            s.integer "i"
+          end
+        end
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "o1" => {
+          "type" => "object",
+          "required" => true,
+          "properties" => {
+            "o2" => {
+              "type" => "object",
+              "required" => true,
+              "properties" => {
+                "o3" => {
+                  "type" => "object",
+                  "required" => true,
+                  "properties" => {
+                    "i" => {
+                      "type" => "integer",
+                      "required" => true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_pattern_properties
+    s = Respect::HashSchema.define do |s|
+      s.hash /o1/ do |s|
+        s.hash /o2/ do |s|
+          s.hash /o3/ do |s|
+            s.integer "i"
+          end
+        end
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "patternProperties" => {
+        "o1" => {
+          "type" => "object",
+          "required" => true,
+          "patternProperties" => {
+            "o2" => {
+              "type" => "object",
+              "required" => true,
+              "patternProperties" => {
+                "o3" => {
+                  "type" => "object",
+                  "required" => true,
+                  "properties" => {
+                    "i" => {
+                      "type" => "integer",
+                      "required" => true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_extra_properties
+    s = Respect::HashSchema.define do |s|
+      s.extra do |s|
+        s.hash "o1" do |s|
+          s.extra do |s|
+            s.hash "o2" do |s|
+              s.extra do |s|
+                s.hash "o3" do |s|
+                  s.integer "i"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "additionalProperties" => {
+        "o1" => {
+          "type" => "object",
+          "additionalProperties" => {
+            "o2" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "o3" => {
+                  "type" => "object",
+                  "properties" => {
+                    "i" => {
+                      "type" => "integer",
+                      "required" => true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_empty_hash_properties
+    s = Respect::HashSchema.define do |s|
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_empty_hash_optional_properties
+    s = Respect::HashSchema.define do |s|
+      s.extra do |s|
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_hash_in_strict_mode
+    s = Respect::HashSchema.define strict: true do |s|
+      s.integer "i"
+      s.string /s/
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => { "i" => { "type" => "integer", "required" => true } },
+      "patternProperties" => { "s" => { "type" => "string", "required" => true } },
+      "additionalProperties" => false,
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_nodoc_hash_properties
+    s = Respect::HashSchema.define do |s|
+      s.integer "enabled"
+      s.integer "nodoc", doc: false
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => { "enabled" => { "type" => "integer", "required" => true } },
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_nodoc_hash_optional_properties
+    s = Respect::HashSchema.define do |s|
+      s.extra do |s|
+        s.integer "enabled"
+        s.integer "nodoc", doc: false
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "additionalProperties" => { "enabled" => { "type" => "integer" } },
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_nodoc_hash_pattern_properties
+    s = Respect::HashSchema.define do |s|
+      s.integer /enabled/
+      s.integer /nodoc/, doc: false
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "patternProperties" => { "enabled" => { "type" => "integer", "required" => true } },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_array_item
+    s = Respect::ArraySchema.define do |s|
+      s.integer
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "items" => {
+        "type" => "integer",
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_array_items
+    s = Respect::ArraySchema.define do |s|
+      s.items do |s|
+        s.integer
+        s.string
+        s.float
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "items" => [
+        { "type" => "integer" },
+        { "type" => "string" },
+        { "type" => "number" },
+      ],
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_array_items_and_extra_items
+    s = Respect::ArraySchema.define do |s|
+      s.items do |s|
+        s.integer
+      end
+      s.extra_items do |s|
+        s.string
+        s.float
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "items" => [
+        { "type" => "integer" },
+      ],
+      "additionalItems" => [
+        { "type" => "string" },
+        { "type" => "number" },
+      ],
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_array_extra_items
+    s = Respect::ArraySchema.define do |s|
+      s.extra_items do |s|
+        s.string
+        s.float
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "additionalItems" => [
+        { "type" => "string" },
+        { "type" => "number" },
+      ],
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_array_item
+    s = Respect::ArraySchema.define do |s|
+      s.array do |s|
+        s.array do |s|
+          s.integer
+        end
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "items" => {
+        "type" => "array",
+        "items" => {
+          "type" => "array",
+          "items" => {
+            "type" => "integer",
+          },
+        },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_array_items
+    s = Respect::ArraySchema.define do |s|
+      s.items do |s|
+        s.array do |s|
+          s.items do |s|
+            s.array do |s|
+              s.items do |s|
+                s.integer
+                s.string
+              end
+            end
+            s.integer
+            s.string
+          end
+        end
+        s.integer
+        s.string
+        s.float
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "items" => [
+        {
+          "type" => "array",
+          "items" => [
+            {
+              "type" => "array",
+              "items" => [
+                { "type" => "integer" },
+                { "type" => "string" },
+              ],
+            },
+            { "type" => "integer" },
+            { "type" => "string" },
+          ],
+        },
+        { "type" => "integer" },
+        { "type" => "string" },
+        { "type" => "number" },
+      ],
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_array_extra_items
+    s = Respect::ArraySchema.define do |s|
+      s.extra_items do |s|
+        s.array do |s|
+          s.extra_items do |s|
+            s.array do |s|
+              s.extra_items do |s|
+                s.integer
+                s.string
+              end
+            end
+            s.integer
+            s.string
+          end
+        end
+        s.integer
+        s.string
+        s.float
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+      "additionalItems" => [
+        {
+          "type" => "array",
+          "additionalItems" => [
+            {
+              "type" => "array",
+              "additionalItems" => [
+                { "type" => "integer" },
+                { "type" => "string" },
+              ],
+            },
+            { "type" => "integer" },
+            { "type" => "string" },
+          ],
+        },
+        { "type" => "integer" },
+        { "type" => "string" },
+        { "type" => "number" },
+      ],
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_empty_array_item
+    s = Respect::ArraySchema.define do |s|
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_empty_array_items
+    s = Respect::ArraySchema.define do |s|
+      s.items do |s|
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+    }
+    assert_equal e, a
+  end
+
+  def test_do_not_dump_empty_array_extra_items
+    s = Respect::ArraySchema.define do |s|
+      s.extra_items do |s|
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "array",
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_option_required
+    s = Respect::HashSchema.define do |s|
+      s.integer "required_i"
+      s.integer "default_i", default: 42
+      s.integer "non_required_i", required: false
+      s.extra do |s|
+        s.integer "optional_i"
+      end
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "required_i" => { "type" => "integer", "required" => true },
+      },
+      "additionalProperties" => {
+        "default_i" => { "type" => "integer", "default" => 42 },
+        "non_required_i" => { "type" => "integer" },
+        "optional_i" => { "type" => "integer" },
+      },
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_integer_single_option_with_trivial_translation
+    {
+      integer: {
+        divisible_by: { value: 2, trans: { "divisibleBy" => 2 } },
+        multiple_of: { value: 2, trans: { "divisibleBy" => 2 } },
+        in: { value: [ 2, 3, 4 ], trans: { "enum" => [ 2, 3, 4 ] } },
+        equal_to: { value: 2, trans: { "enum" => [ 2 ] } },
+        greater_than: { value: 2, trans: { "minimum" => 2, "exclusiveMinimum" => true } },
+        greater_than_or_equal_to: { value: 2, trans: { "minimum" => 2 } },
+        less_than: { value: 2, trans: { "maximum" => 2, "exclusiveMaximum" => true } },
+        less_than_or_equal_to: { value: 2, trans: { "maximum" => 2 } },
+      },
+      string: {
+        match: { value: /s.*t/, trans: { "pattern" => "s.*t" } },
+        min_length: { value: 42, trans: { "minLength" => 42 } },
+        max_length: { value: 42, trans: { "maxLength" => 42 } },
+      },
+      array: {
+        uniq: { value: true, trans: { "uniqueItems" => true } },
+        min_size: { value: 42, trans: { "minItems" => 42 } },
+        max_size: { value: 42, trans: { "maxItems" => 42 } },
+      },
+    }.each do |statement, options|
+      options.each do |opt, params|
+        s = Respect::Schema.define do |s|
+          s.__send__(statement, { opt => params[:value] })
+        end
+        a = Respect::Org3Dumper.new(s).dump
+        e = { "type" => statement.to_s }.merge(params[:trans])
+        assert_equal e, a, "dump option #{opt} for statement #{statement}"
+        # Test option value are not shared between the hash and the schema.
+        params[:trans].each do |k, v|
+          unless v.is_a?(Numeric) || v.is_a?(TrueClass) || v.is_a?(FalseClass)
+            assert(s.options[opt].object_id != a[k].object_id,
+              "non shared option value for option '#{opt}' for statement '#{statement}'")
+          end
+        end
+      end
+    end
+  end
+
+  def test_dump_option_format
+    {
+      email: 'email',
+      uri: 'uri',
+      regexp: 'regex',
+      datetime: 'date-time',
+      ipv4_addr: 'ip-address',
+      phone_number: 'phone',
+      ipv6_addr: 'ipv6',
+      hostname: 'host-name',
+    }.each do |format, type|
+      s = Respect::Schema.define do |s|
+        s.string format: format
+      end
+      a = Respect::Org3Dumper.new(s).dump
+      e = {
+        "type" => "string",
+        "format" => type,
+      }
+      assert_equal e, a, "dump format #{format}"
+    end
+  end
+
+  # FIXME(Nicolas Despres): Test ip_addr format warn that it cannot be dumped
+
+  def test_dump_documentation
+    [
+      { doc: "a title\n\na description",
+        expected: { "title" => "a title", "description" => "a description" },
+        message: "complete documentation",
+      },
+      { doc: "a long ... \n ... description",
+        expected: { "description" => "a long ... \n ... description" },
+        message: "documentation with no title",
+      },
+      { doc: "a title",
+        expected: { "title" => "a title" },
+        message: "documentation with no description",
+      },
+    ].each do |data|
+      s = Respect::Schema.define do |s|
+        s.doc data[:doc]
+        s.integer
+      end
+      a = Respect::Org3Dumper.new(s).dump
+      e = { "type" => "integer" }.merge(data[:expected])
+      assert_equal e, a, data[:message]
+    end
+  end
+
+  def test_no_dump_for_nodoc
+    BASIC_STATEMENTS_LIST.each do |statement|
+      s = Respect::Schema.define do |s|
+        s.__send__(statement, doc: false)
+      end
+      assert_nil Respect::Org3Dumper.new(s).dump
+    end
+  end
+
+  def test_no_dump_for_non_empty_hash
+    s = Respect::Schema.define do |s|
+      s.hash doc: false do |s|
+        s.integer "i"
+        s.string "s"
+      end
+    end
+    assert_nil Respect::Org3Dumper.new(s).dump
+  end
+
+  def test_no_dump_for_non_empty_array
+    s = Respect::Schema.define do |s|
+      s.array doc: false do |s|
+        s.integer
+      end
+    end
+    assert_nil Respect::Org3Dumper.new(s).dump
+  end
+
+  def test_dump_composite_schema
+    s = Respect::HashSchema.define do |s|
+      s.point "origin"
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "origin" => {
+          "type" => "object",
+          "required" => true,
+          "properties" => {
+            "x" => { "type" => "number", "required" => true },
+            "y" => { "type" => "number", "required" => true },
+          }
+        }
+      }
+    }
+    assert_equal e, a
+  end
+
+  def test_dump_nested_composite_schema
+    s = Respect::HashSchema.define do |s|
+      s.circle "area"
+    end
+    a = Respect::Org3Dumper.new(s).dump
+    e = {
+      "type" => "object",
+      "properties" => {
+        "area" => {
+          "type" => "object",
+          "required" => true,
+          "properties" => {
+            "center" => {
+              "type" => "object",
+              "required" => true,
+              "properties" => {
+                "x" => { "type" => "number", "required" => true },
+                "y" => { "type" => "number", "required" => true },
+              }
+            },
+            "radius" => {
+              "type" => "number",
+              "required" => true,
+              "minimum" => 0.0,
+              "exclusiveMinimum" => true
+            }
+          }
+        }
+      }
+    }
+    assert_equal e, a
+  end
+
+  def test_custom_validator
+    assert_equal({ "type" => "integer", "minimum" => 42, "maximum" => 42 },
+      Respect::IntegerSchema.new(universal: true).to_h(:org3))
+  end
+
+end