emery 0.0.2 → 0.0.8

data/test/enum_test.rb

@@ -1,47 +1,43 @@
 require "test/unit/runner/junitxml"
 
-require 'emery/type'
-require 'emery/enum'
-require 'emery/jsoner'
-
-module Emery
-  class TypeCheckEnum < Test::Unit::TestCase
-    def test_success
-      assert_equal SomeEnum::one, T.check(SomeEnum, SomeEnum::one), "Plain enum type should pass type check"
-    end
+require 'emery'
 
-    def test_fail
-      assert_raise TypeError do
-        T.check(SomeEnum, "non existing")
-      end
-    end
+class TypeCheckEnum < Test::Unit::TestCase
+  def test_success
+    assert_equal SomeEnum::one, T.check(SomeEnum, SomeEnum::one), "Plain enum type should pass type check"
   end
 
-  class EnumDeserialization < Test::Unit::TestCase
-    def test_deserialize_enum
-      data = Jsoner.from_json(SomeEnum, '"two"')
-      T.check(SomeEnum, data)
-      assert_equal SomeEnum::two, data, "Enum should be parsable from JSON"
+  def test_fail
+    assert_raise TypeError do
+      T.check(SomeEnum, "non existing")
     end
+  end
+end
 
-    def test_deserialize_enum_non_existing_item
-      assert_raise JsonerError do
-        Jsoner.from_json(SomeEnum, '"non_existing"')
-      end
-    end
+class EnumDeserialization < Test::Unit::TestCase
+  def test_deserialize_enum
+    data = Jsoner.from_json(SomeEnum, '"two"')
+    T.check(SomeEnum, data)
+    assert_equal SomeEnum::two, data, "Enum should be parsable from JSON"
   end
 
-  class EnumSerialization < Test::Unit::TestCase
-    def test_serialize_enum
-      json_str = Jsoner.to_json(SomeEnum, SomeEnum::two)
-      assert_equal '"two"', json_str, "Enum should be serializable to JSON"
+  def test_deserialize_enum_non_existing_item
+    assert_raise JsonerError do
+      Jsoner.from_json(SomeEnum, '"non_existing"')
     end
   end
+end
 
-  class SomeEnum
-    include Enum
-
-    define :one, 'one'
-    define :two, 'two'
+class EnumSerialization < Test::Unit::TestCase
+  def test_serialize_enum
+    json_str = Jsoner.to_json(SomeEnum, SomeEnum::two)
+    assert_equal '"two"', json_str, "Enum should be serializable to JSON"
   end
+end
+
+class SomeEnum
+  include Enum
+
+  define :one, 'one'
+  define :two, 'two'
 end

data/test/jsoner_test.rb

@@ -1,260 +1,285 @@
 require "test/unit/runner/junitxml"
 
-require 'emery/type'
-require 'emery/jsoner'
-
-module Emery
-  class PlainTypesDeserialization < Test::Unit::TestCase
-    def test_deserialize_integer
-      data = Jsoner.from_json(Integer, '123')
-      T.check(Integer, data)
-      assert_equal 123, data, "Integer should be parsable from JSON"
-    end
+require 'emery'
 
-    def test_deserialize_integer_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(Integer, '"abc"')
-      end
-    end
+class PlainTypesDeserialization < Test::Unit::TestCase
+  def test_deserialize_integer
+    data = Jsoner.from_json(Integer, '123')
+    T.check(Integer, data)
+    assert_equal 123, data, "Integer should be parsable from JSON"
+  end
 
-    def test_deserialize_float
-      data = Jsoner.from_json(Float, '1.23')
-      T.check(Float, data)
-      assert_equal 1.23, data, "Float should be parsable from JSON"
+  def test_deserialize_integer_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(Integer, '"abc"')
     end
+  end
 
-    def test_deserialize_float_from_integer
-      data = Jsoner.from_json(Float, '123')
-      T.check(Float, data)
-      assert_equal 123.0, data, "Float should be parsable from JSON"
-    end
+  def test_deserialize_float
+    data = Jsoner.from_json(Float, '1.23')
+    T.check(Float, data)
+    assert_equal 1.23, data, "Float should be parsable from JSON"
+  end
 
-    def test_deserialize_float_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(Float, '"abc"')
-      end
-    end
+  def test_deserialize_float_from_integer
+    data = Jsoner.from_json(Float, '123')
+    T.check(Float, data)
+    assert_equal 123.0, data, "Float should be parsable from JSON"
+  end
 
-    def test_deserialize_boolean
-      data = Jsoner.from_json(Boolean, 'true')
-      T.check(Boolean, data)
-      assert_equal true, data, "Boolean should be parsable from JSON"
+  def test_deserialize_float_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(Float, '"abc"')
     end
+  end
 
-    def test_deserialize_boolean_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(Boolean, '1')
-      end
-    end
+  def test_deserialize_true
+    data = Jsoner.from_json(Boolean, 'true')
+    T.check(Boolean, data)
+    assert_equal true, data, "Boolean true should be parsable from JSON"
+  end
 
-    def test_deserialize_string
-      data = Jsoner.from_json(String, '"the string"')
-      T.check(String, data)
-      assert_equal "the string", data, "String should be parsable from JSON"
-    end
+  def test_deserialize_false
+    data = Jsoner.from_json(Boolean, 'false')
+    T.check(Boolean, data)
+    assert_equal false, data, "Boolean false should be parsable from JSON"
+  end
 
-    def test_deserialize_string_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(String, '123')
-      end
+  def test_deserialize_boolean_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(Boolean, '1')
     end
+  end
 
-    def test_deserialize_uuid
-      data = Jsoner.from_json(UUID, '"58d5e212-165b-4ca0-909b-c86b9cee0111"')
-      T.check(UUID, data)
-      assert_equal "58d5e212-165b-4ca0-909b-c86b9cee0111", data, "String should be parsable from JSON"
-    end
+  def test_deserialize_string
+    data = Jsoner.from_json(String, '"the string"')
+    T.check(String, data)
+    assert_equal "the string", data, "String should be parsable from JSON"
+  end
 
-    def test_deserialize_uuid_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(UUID, '"abc"')
-      end
+  def test_deserialize_string_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(String, '123')
     end
+  end
 
-    def test_deserialize_date
-      data = Jsoner.from_json(Date, '"2019-11-30"')
-      T.check(Date, data)
-      assert_equal Date.new(2019, 11, 30), data, "Date should be parsable from JSON"
-    end
+  def test_deserialize_uuid
+    data = Jsoner.from_json(UUID, '"58d5e212-165b-4ca0-909b-c86b9cee0111"')
+    T.check(UUID, data)
+    assert_equal "58d5e212-165b-4ca0-909b-c86b9cee0111", data, "String should be parsable from JSON"
+  end
 
-    def test_deserialize_date_wrong_format
-      assert_raise JsonerError do
-        Jsoner.from_json(Date, '"11/30/2019"')
-      end
+  def test_deserialize_uuid_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(UUID, '"abc"')
     end
+  end
 
-    def test_deserialize_datetime
-      data = Jsoner.from_json(DateTime, '"2019-11-30T17:45:55+00:00"')
-      T.check(DateTime, data)
-      assert_equal DateTime.new(2019, 11, 30, 17, 45, 55), data, "DateTime should be parsable from JSON"
-    end
+  def test_deserialize_date
+    data = Jsoner.from_json(Date, '"2019-11-30"')
+    T.check(Date, data)
+    assert_equal Date.new(2019, 11, 30), data, "Date should be parsable from JSON"
+  end
 
-    def test_deserialize_datetime_wrong_format
-      assert_raise JsonerError do
-        Jsoner.from_json(DateTime, '"2019-11-30 17:45:55"')
-      end
+  def test_deserialize_date_wrong_format
+    assert_raise JsonerError do
+      Jsoner.from_json(Date, '"11/30/2019"')
     end
+  end
 
-    def test_deserialize_nilable_nil
-      data = Jsoner.from_json(T.nilable(String), 'null')
-      T.check(T.nilable(String), data)
-      assert_equal nil, data, "Nilable null value should be parsable from JSON"
-    end
+  def test_deserialize_datetime
+    data = Jsoner.from_json(DateTime, '"2019-11-30T17:45:55+00:00"')
+    T.check(DateTime, data)
+    assert_equal DateTime.new(2019, 11, 30, 17, 45, 55), data, "DateTime should be parsable from JSON"
+  end
 
-    def test_deserialize_nilable_string
-      data = Jsoner.from_json(T.nilable(String), '"some string"')
-      T.check(T.nilable(String), data)
-      assert_equal "some string", data, "Nilable non-null value should be parsable from JSON"
+  def test_deserialize_datetime_wrong_format
+    assert_raise JsonerError do
+      Jsoner.from_json(DateTime, '"2019-11-30 17:45:55"')
     end
+  end
 
-    def test_deserialize_non_nilable
-      assert_raise JsonerError do
-        Jsoner.from_json(String, 'null')
-      end
-    end
+  def test_deserialize_nilable_nil
+    data = Jsoner.from_json(T.nilable(String), 'null')
+    T.check(T.nilable(String), data)
+    assert_equal nil, data, "Nilable null value should be parsable from JSON"
   end
 
-  class PlainTypesSerialization < Test::Unit::TestCase
-    def test_serialize_integer
-      assert_equal "123", Jsoner.to_json(Integer,123), "Integer should be serializable to JSON"
-    end
+  def test_deserialize_nilable_string
+    data = Jsoner.from_json(T.nilable(String), '"some string"')
+    T.check(T.nilable(String), data)
+    assert_equal "some string", data, "Nilable non-null value should be parsable from JSON"
+  end
 
-    def test_serialize_integer_fail
-      assert_raise JsonerError do
-        Jsoner.to_json(Integer,123.4)
-      end
+  def test_deserialize_non_nilable
+    assert_raise JsonerError do
+      Jsoner.from_json(String, 'null')
     end
+  end
+end
 
-    def test_serialize_float
-      assert_equal "12.3", Jsoner.to_json(Float,12.3), "Float should be serializable to JSON"
-    end
+class PlainTypesSerialization < Test::Unit::TestCase
+  def test_serialize_integer
+    assert_equal "123", Jsoner.to_json(Integer,123), "Integer should be serializable to JSON"
+  end
 
-    def test_serialize_float_fail
-      assert_raise JsonerError do
-        Jsoner.to_json(Float,123)
-      end
+  def test_serialize_integer_fail
+    assert_raise JsonerError do
+      Jsoner.to_json(Integer,123.4)
     end
+  end
 
-    def test_serialize_boolean
-      assert_equal "true", Jsoner.to_json(Boolean, true), "Boolean should be serializable to JSON"
-    end
+  def test_serialize_float
+    assert_equal "12.3", Jsoner.to_json(Float,12.3), "Float should be serializable to JSON"
+  end
 
-    def test_serialize_string
-      assert_equal '"the string"', Jsoner.to_json(String,"the string"), "String should be serializable to JSON"
+  def test_serialize_float_fail
+    assert_raise JsonerError do
+      Jsoner.to_json(Float,123)
     end
+  end
 
-    def test_serialize_date
-      assert_equal '"2019-11-30"', Jsoner.to_json(Date, Date.new(2019, 11, 30)), "Date should be serializable to JSON"
-    end
+  def test_serialize_boolean
+    assert_equal "true", Jsoner.to_json(Boolean, true), "Boolean should be serializable to JSON"
+  end
 
-    def test_serialize_date_fail
-      assert_raise JsonerError do
-        Jsoner.to_json(Date, 123)
-      end
-    end
+  def test_serialize_string
+    assert_equal '"the string"', Jsoner.to_json(String,"the string"), "String should be serializable to JSON"
+  end
 
-    def test_serialize_datetime
-      assert_equal '"2019-11-30T17:45:55"', Jsoner.to_json(DateTime, DateTime.new(2019, 11, 30, 17, 45, 55)), "DateTime should be serializable to JSON"
-    end
+  def test_serialize_date
+    assert_equal '"2019-11-30"', Jsoner.to_json(Date, Date.new(2019, 11, 30)), "Date should be serializable to JSON"
+  end
 
-    def test_serialize_nil
-      json_str = Jsoner.to_json(T.nilable(Untyped), nil)
-      assert_equal "null", json_str, "nil should be serializable to JSON"
+  def test_serialize_date_fail
+    assert_raise JsonerError do
+      Jsoner.to_json(Date, 123)
     end
+  end
 
-    def test_serialize_uuid
-      assert_equal '"58d5e212-165b-4ca0-909b-c86b9cee0111"', Jsoner.to_json(UUID, "58d5e212-165b-4ca0-909b-c86b9cee0111"), "UUID should be serializable to JSON"
-    end
+  def test_serialize_datetime
+    assert_equal '"2019-11-30T17:45:55"', Jsoner.to_json(DateTime, DateTime.new(2019, 11, 30, 17, 45, 55)), "DateTime should be serializable to JSON"
   end
 
-  class ArrayDeserialization < Test::Unit::TestCase
-    def test_deserialize_array
-      data = Jsoner.from_json(T.array(String), '["the string", "the other string"]')
-      T.check(T.array(String), data)
-      assert_equal ["the string", "the other string"], data, "Should parse array of strings"
-    end
+  def test_serialize_nil
+    json_str = Jsoner.to_json(T.nilable(Untyped), nil)
+    assert_equal "null", json_str, "nil should be serializable to JSON"
+  end
 
-    def test_deserialize_array_of_datetime
-      data = Jsoner.from_json(T.array(DateTime), '["2019-11-30T17:45:55+00:00"]')
-      T.check(T.array(DateTime), data)
-      assert_equal [DateTime.new(2019, 11, 30, 17, 45, 55)], data, "Should parse array of DateTime"
-    end
+  def test_serialize_uuid
+    assert_equal '"58d5e212-165b-4ca0-909b-c86b9cee0111"', Jsoner.to_json(UUID, "58d5e212-165b-4ca0-909b-c86b9cee0111"), "UUID should be serializable to JSON"
   end
+end
 
-  class ArraySerialization < Test::Unit::TestCase
-    def test_serialize_array
-      assert_equal '["the string","the other string"]', Jsoner.to_json(T.array(String), ["the string", "the other string"]), "Array should be serializable to JSON"
-    end
+class ArrayDeserialization < Test::Unit::TestCase
+  def test_deserialize_array
+    data = Jsoner.from_json(T.array(String), '["the string", "the other string"]')
+    T.check(T.array(String), data)
+    assert_equal ["the string", "the other string"], data, "Should parse array of strings"
+  end
 
-    def test_serialize_array_of_datetime
-      assert_equal '["2019-11-30T17:45:55"]', Jsoner.to_json(T.array(DateTime), [DateTime.new(2019, 11, 30, 17, 45, 55)]), "Array should be serializable to JSON"
-    end
+  def test_deserialize_array_of_datetime
+    data = Jsoner.from_json(T.array(DateTime), '["2019-11-30T17:45:55+00:00"]')
+    T.check(T.array(DateTime), data)
+    assert_equal [DateTime.new(2019, 11, 30, 17, 45, 55)], data, "Should parse array of DateTime"
   end
+end
 
-  class HashDeserialization < Test::Unit::TestCase
-    def test_deserialize_hash
-      data = Jsoner.from_json(T.hash(String, Integer), '{"one": 123, "two": 456}')
-      T.check(T.hash(String, Integer), data)
-      assert_equal ({"one" => 123, "two" => 456}), data, "Should parse hash"
-    end
+class ArraySerialization < Test::Unit::TestCase
+  def test_serialize_array
+    assert_equal '["the string","the other string"]', Jsoner.to_json(T.array(String), ["the string", "the other string"]), "Array should be serializable to JSON"
+  end
 
-    def test_deserialize_hash_string_to_datetime
-      data = Jsoner.from_json(T.hash(String, DateTime), '{"one": "2019-11-30T17:45:55+00:00"}')
-      T.check(T.hash(String, DateTime), data)
-      assert_equal ({"one" => DateTime.new(2019, 11, 30, 17, 45, 55)}), data, "Should parse hash"
-    end
+  def test_serialize_array_of_datetime
+    assert_equal '["2019-11-30T17:45:55"]', Jsoner.to_json(T.array(DateTime), [DateTime.new(2019, 11, 30, 17, 45, 55)]), "Array should be serializable to JSON"
   end
+end
 
-  class HashSerialization < Test::Unit::TestCase
-    def test_serialize_hash
-      assert_equal '{"one":123,"two":456}', Jsoner.to_json(T.hash(String, Integer), {"one" => 123, "two" => 456}), "Hash should be serializable to JSON"
-    end
+class HashDeserialization < Test::Unit::TestCase
+  def test_deserialize_hash
+    data = Jsoner.from_json(T.hash(String, Integer), '{"one": 123, "two": 456}')
+    T.check(T.hash(String, Integer), data)
+    assert_equal ({"one" => 123, "two" => 456}), data, "Should parse hash"
+  end
 
-    def test_serialize_hash_string_to_datetime
-      assert_equal '{"one":"2019-11-30T17:45:55"}', Jsoner.to_json(T.hash(String, DateTime), {"one" => DateTime.new(2019, 11, 30, 17, 45, 55)}), "Hash should be serializable to JSON"
-    end
+  def test_deserialize_hash_string_to_datetime
+    data = Jsoner.from_json(T.hash(String, DateTime), '{"one": "2019-11-30T17:45:55+00:00"}')
+    T.check(T.hash(String, DateTime), data)
+    assert_equal ({"one" => DateTime.new(2019, 11, 30, 17, 45, 55)}), data, "Should parse hash"
   end
+end
 
-  class AnyDeserialization < Test::Unit::TestCase
-    def test_deserialize
-      data = Jsoner.from_json(T.any(String, Integer), '"the string"')
-      T.check(T.any(String, Integer), data)
-      assert_equal "the string", data, "Should parse any type"
-    end
+class HashSerialization < Test::Unit::TestCase
+  def test_serialize_hash
+    assert_equal '{"one":123,"two":456}', Jsoner.to_json(T.hash(String, Integer), {"one" => 123, "two" => 456}), "Hash should be serializable to JSON"
+  end
 
-    def test_deserialize_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(T.any(Integer, Float), '"the string"')
-      end
-    end
+  def test_serialize_hash_string_to_datetime
+    assert_equal '{"one":"2019-11-30T17:45:55"}', Jsoner.to_json(T.hash(String, DateTime), {"one" => DateTime.new(2019, 11, 30, 17, 45, 55)}), "Hash should be serializable to JSON"
   end
+end
 
-  class AnySerialization < Test::Unit::TestCase
-    def test_serialize
-      data = Jsoner.to_json(T.any(String, Integer), "the string")
-      T.check(T.any(String, Integer), data)
-      assert_equal '"the string"', data, "Should serialize any type"
-    end
+class UntypedDeserialization < Test::Unit::TestCase
+  def test_deserialize_hash
+    data = Jsoner.from_json(Untyped, '{"one":123,"two":"some string"}')
+    assert_equal ({"one" => 123, "two" => "some string"}), data
   end
 
-  class UnionDeserialization < Test::Unit::TestCase
-    def test_deserialize
-      data = Jsoner.from_json(T.union(str: String, int: Integer), '{"str":"the string"}')
-      T.check(T.union(str: String, int: Integer), data)
-      assert_equal "the string", data, "Should parse union type"
-    end
+  def test_deserialize_array
+    data = Jsoner.from_json(Untyped, '[123,"some string"]')
+    assert_equal [123, "some string"], data
+  end
+end
+
+class UntypedSerialization < Test::Unit::TestCase
+  def test_serialize_hash
+    assert_equal '{"one":123,"two":"some string"}', Jsoner.to_json(Untyped, {"one" => 123, "two" => "some string"})
+  end
+
+  def test_serialize_array
+    assert_equal '[123,"some string"]', Jsoner.to_json(Untyped, [123, "some string"])
+  end
+end
+
+class AnyDeserialization < Test::Unit::TestCase
+  def test_deserialize
+    data = Jsoner.from_json(T.any(String, Integer), '"the string"')
+    T.check(T.any(String, Integer), data)
+    assert_equal "the string", data, "Should parse any type"
+  end
 
-    def test_deserialize_any_fail
-      assert_raise JsonerError do
-        Jsoner.from_json(T.union(str: String, int: Integer), '{"bool":true}')
-      end
+  def test_deserialize_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(T.any(Integer, Float), '"the string"')
     end
   end
+end
+
+class AnySerialization < Test::Unit::TestCase
+  def test_serialize
+    data = Jsoner.to_json(T.any(String, Integer), "the string")
+    T.check(T.any(String, Integer), data)
+    assert_equal '"the string"', data, "Should serialize any type"
+  end
+end
 
-  class UnionSerialization < Test::Unit::TestCase
-    def test_serialize
-      data = Jsoner.to_json(T.union(str: String, int: Integer), "the string")
-      assert_equal '{"str":"the string"}', data, "Should serialize union type with wrapping object"
+class UnionDeserialization < Test::Unit::TestCase
+  def test_deserialize
+    data = Jsoner.from_json(T.union(str: String, int: Integer), '{"str":"the string"}')
+    T.check(T.union(str: String, int: Integer), data)
+    assert_equal "the string", data, "Should parse union type"
+  end
+
+  def test_deserialize_any_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(T.union(str: String, int: Integer), '{"bool":true}')
     end
   end
+end
+
+class UnionSerialization < Test::Unit::TestCase
+  def test_serialize
+    data = Jsoner.to_json(T.union(str: String, int: Integer), "the string")
+    assert_equal '{"str":"the string"}', data, "Should serialize union type with wrapping object"
+  end
 end