ohm-contrib 0.0.31 → 0.0.33

data/test/typecast_array_test.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Post < Ohm::Model
+  include Ohm::Typecast
+
+  attribute :addresses, Array
+
+  def array
+    Array.new
+  end
+
+  def top_level_array
+    Array
+  end
+end
+
+test "importing" do
+  assert [] == Ohm::Types::Array[nil]
+  assert [] == Ohm::Types::Array[""]
+  assert [] == Ohm::Types::Array[[]]
+
+  assert ['a', 'b', 'c', 'd'] == Ohm::Types::Array[['a', 'b', 'c', 'd']]
+end
+
+test "exporting / dumping" do
+  assert "[]" == Ohm::Types::Array[nil].to_s
+  assert "[]" == Ohm::Types::Array[""].to_s
+  assert "[]" == Ohm::Types::Array[[]].to_s
+
+  assert %q{["a","b","c","d"]} == Ohm::Types::Array[['a', 'b', 'c', 'd']].to_s
+end
+
+test "still able to get top level methods" do
+  assert [] == Post.new.array
+  assert Array == Post.new.top_level_array
+end
+
+test "handles nil case correctly" do
+  post = Post.create(:addresses => nil)
+  assert [] == post.addresses
+
+  post = Post[post.id]
+  assert [] == post.addresses
+end
+
+test "handles empty string case correctly" do
+  post = Post.create(:addresses => "")
+  assert [] == post.addresses
+
+  post = Post[post.id]
+  assert [] == post.addresses
+end
+
+test "handles populated arrays" do
+  addresses = [{"city" => "Singapore", "country" => "SG"},
+               {"city" => "Manila", "country" => "PH"}]
+
+  post = Post.create(:addresses => addresses)
+  assert addresses == post.addresses
+
+  post = Post[post.id]
+  assert addresses == post.addresses
+end
+
+class AddressArr < Class.new(Struct.new(:city, :country))
+  def to_json(*args)
+    [city, country].to_json(*args)
+  end
+end
+
+test "handles an arbitrary class as an element of the array" do
+  addresses = [AddressArr.new("Singapore", "SG"),
+               AddressArr.new("Philippines", "PH")]
+
+  post = Post.create(:addresses => addresses)
+  assert [['Singapore', 'SG'], ['Philippines', 'PH']] == post.addresses
+
+  post = Post[post.id]
+  assert [['Singapore', 'SG'], ['Philippines', 'PH']] == post.addresses
+end
+
+test "allows for array operations" do
+  addresses = [{"city" => "Singapore", "country" => "SG"},
+               {"city" => "Manila", "country" => "PH"}]
+
+
+  post = Post.create(:addresses => addresses)
+  assert 2 == post.addresses.size
+
+  expected = addresses + [{"city" => "Hong Kong", "country" => "ZN"}]
+  actual   = post.addresses.push({"city" => "Hong Kong", "country" => "ZN"})
+
+  assert expected == actual
+
+  post = Post[post.id]
+  assert 2 == post.addresses.size
+
+  expected = addresses + [{"city" => "Hong Kong", "country" => "ZN"}]
+  actual   = post.addresses.push({ "city" => "Hong Kong", "country" => "ZN" })
+
+  assert expected == actual
+end
+
+test "looping! and other enumerablems" do
+  array = [1, 2, 3]
+  post = Post.create(:addresses => array)
+
+  total = 0
+  post.addresses.each { |e| total += e }
+  assert 6 == total
+
+  post = Post[post.id]
+  total = 0
+  post.addresses.each { |e| total += e }
+  assert 6 == total
+end
+
+test "handles mutation" do
+  post = Post.create(:addresses => [1, 2, 3])
+
+  post.addresses.push(4, 5, 6)
+  post.save
+
+  assert [1, 2, 3, 4, 5, 6] == post.addresses
+
+  post = Post[post.id]
+  assert [1, 2, 3, 4, 5, 6] == post.addresses
+end
+
+test "raises when trying to assign a non-array" do
+  assert_raise TypeError do
+    Post.new(:addresses => {})
+  end
+
+  assert_raise TypeError do
+    Post.new(:addresses => AddressArr.new)
+  end
+end
+
+test "inspecting" do
+  post = Post.create(:addresses => [{ "address1" => "#456",
+                                      "city" => "Singapore",
+                                      "country" => "SG" }])
+
+  expected = %q{[{"address1":"#456","city":"Singapore","country":"SG"}]}
+
+  assert expected == post.addresses.inspect
+
+  post.addresses = 'FooBar'
+  assert %{"\\\"FooBar\\\""} == post.addresses.inspect
+end
+

data/test/typecast_boolean_test.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class User < Ohm::Model
+  include Ohm::Typecast
+
+  attribute :is_admin, Boolean
+end
+
+test "empty is nil" do
+  assert nil == User.new.is_admin
+
+  u = User.create
+  u = User[u.id]
+
+  assert nil == User.new.is_admin
+end
+
+test "false, 0, '0' is false" do
+  [false, 0, '0'].each do |val|
+    assert false == User.new(:is_admin => val).is_admin
+  end
+
+  [false, 0, '0'].each do |val|
+    u = User.create(:is_admin => val)
+    u = User[u.id]
+    assert false == u.is_admin
+  end
+end
+
+test "true, 1, '1' is true" do
+  [true, 1, '1'].each do |val|
+    assert true == User.new(:is_admin => val).is_admin
+  end
+
+  [true, 1, '1'].each do |val|
+    u = User.create(:is_admin => val)
+    u = User[u.id]
+    assert true == u.is_admin
+  end
+end
+

data/test/typecast_date_test.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Post < Ohm::Model
+  include Ohm::Typecast
+
+  attribute :created_on, Date
+
+  def today
+    ::Date.today
+  end
+
+  def date
+    Date
+  end
+
+  def may_5
+    Date.new(2010, 05, 05)
+  end
+
+  def base_today
+    Date.today
+  end
+end
+
+test "still able to get top level methods" do
+  assert Date.today == Post.new.base_today
+end
+
+test "allows instantiation of dates" do
+  assert Date.new(2010, 05, 05) == Post.new.may_5
+end
+
+test "handles nil case correctly" do
+  post = Post.create(:created_on => nil)
+  post = Post[post.id]
+
+  assert nil == post.created_on
+end
+
+test "handles empty string case correctly" do
+  post = Post.create(:created_on => "")
+  post = Post[post.id]
+
+  assert "" == post.created_on.to_s
+end
+
+test "allows for real time operations" do
+  post = Post.create(:created_on => "2010-05-10")
+  post = Post[post.id]
+
+  assert post.created_on.respond_to?(:strftime)
+  assert "2010-05-10" == post.created_on.strftime('%Y-%m-%d')
+end
+
+test "raises when trying to do date operations on a non-date" do
+  post = Post.create(:created_on => "FooBar")
+  post = Post[post.id]
+
+  assert_raise ArgumentError do
+    post.created_on.strftime("%Y")
+  end
+end
+
+test "still able to access Date" do
+  assert Date.today == Post.new.today
+end
+
+test "inspecting" do
+  post = Post.create(:created_on => Date.new(2010, 5, 5))
+  assert '"2010-05-05"' == post.created_on.inspect
+
+  post.created_on = 'FooBar'
+  assert '"FooBar"' == post.created_on.inspect
+end
+

data/test/typecast_decimal_test.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Post < Ohm::Model
+  include Ohm::Typecast
+
+  attribute :price, Decimal
+end
+
+test "handles nil case correctly" do
+  post = Post.create(:price => nil)
+  post = Post[post.id]
+
+  assert nil == post.price
+end
+
+test "handles empty string case correctly" do
+  post = Post.create(:price => "")
+  post = Post[post.id]
+
+  assert "" == post.price.to_s
+end
+
+test "allows for real arithmetic" do
+  post = Post.create(:price => "0.01")
+  post = Post[post.id]
+
+  assert 0.02   == post.price + post.price
+  assert 0.0    == post.price - post.price
+  assert 0.0001 == post.price * post.price
+  assert 1.0    == post.price / post.price
+end
+
+test "is accurate accdg to the decimal spec" do
+  post = Post.create(:price => "0.0001")
+  post = Post[post.id]
+
+  sum = 0
+  1_000.times { sum += post.price }
+  assert 0.1 == sum
+end
+
+test "using += with price" do
+  post = Post.create(:price => "0.0001")
+  post = Post[post.id]
+
+  post.price += 1
+  assert 1.0001 == post.price.to_f
+end
+
+test "assigning a raw BigDecimal" do
+  post = Post.create(:price => BigDecimal("399.50"))
+  post = Post[post.id]
+
+  assert post.price.to_s.kind_of?(String)
+end
+
+test "equality and comparable matching" do
+  post = Post.create(:price => "399.50")
+  assert (post.price == "399.50")
+  assert (post.price < 399.51)
+  assert (post.price > 399.49)
+  assert (post.price <= 399.50)
+  assert (post.price <= 399.51)
+  assert (post.price >= 399.50)
+  assert (post.price >= 399.49)
+end
+
+test "inspecting a Decimal" do
+  post = Post.new(:price => 399.50)
+  assert '"399.5"' == post.price.inspect
+
+  post.price = 'FooBar'
+  assert '"FooBar"' == post.price.inspect
+end
+

data/test/typecast_float_test.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Post < Ohm::Model
+  include Ohm::Typecast
+
+  attribute :price, Float
+end
+
+test "handles nil case correctly" do
+  post = Post.create(:price => nil)
+  post = Post[post.id]
+
+  assert nil == post.price
+end
+
+test "handles empty string case correctly" do
+  post = Post.create(:price => "")
+  post = Post[post.id]
+
+  assert "" == post.price.to_s
+end
+
+test "allows for real arithmetic" do
+  post = Post.create(:price => "3")
+  post = Post[post.id]
+
+  assert 6.0 == post.price + post.price
+  assert 0.0 == post.price - post.price
+  assert 9.0 == post.price * post.price
+  assert 1.0 == post.price / post.price
+end
+
+test "raises when trying to do arithmetic ops on a non-float" do
+
+  post = Post.create(:price => "FooBar")
+  post = Post[post.id]
+
+  assert_raise ArgumentError do
+    post.price * post.price
+  end
+end
+
+test "inspecting" do
+  post = Post.new(:price => "12345.67890")
+  assert '"12345.67890"' == post.price.inspect
+
+  post.price = 'FooBar'
+  assert '"FooBar"' == post.price.inspect
+end
+

data/test/typecast_hash_test.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Post < Ohm::Model
+  include Ohm::Typecast
+
+  attribute :address, Hash
+
+  def hash
+    Hash.new
+  end
+
+  def top_level_hash
+    Hash
+  end
+end
+
+test "importing" do
+  assert Hash.new == Ohm::Types::Hash[nil]
+  assert Hash.new == Ohm::Types::Hash[""]
+  assert Hash.new == Ohm::Types::Hash[{}]
+
+  expected = Hash[:a => "b", :c => "d"]
+  assert expected == Ohm::Types::Hash[{ :a => "b", :c => "d" }]
+end
+
+test "exporting / dumping" do
+  assert "{}" == Ohm::Types::Hash[nil].to_s
+  assert "{}" == Ohm::Types::Hash[""].to_s
+  assert "{}" == Ohm::Types::Hash[{}].to_s
+
+  expected = %q{{"a":"b","c":"d"}}
+  assert expected == Ohm::Types::Hash[{ :a => "b", :c => "d" }].to_s
+end
+
+test "still able to get top level methods" do
+  assert Post.new.hash == {}
+  assert Hash == Post.new.top_level_hash
+end
+
+test "handles nil case correctly" do
+  post = Post.create(:address => nil)
+  assert post.address == {}
+
+  post = Post[post.id]
+  assert post.address == {}
+end
+
+test "handles empty string case correctly" do
+  post = Post.create(:address => "")
+  assert post.address == {}
+
+  post = Post[post.id]
+  assert post.address == {}
+end
+
+test "handles populated hashes" do
+  address = { "address1" => "#123", "city" => "Singapore", "country" => "SG"}
+  post = Post.create(:address => address)
+  assert address == post.address
+
+  post = Post[post.id]
+  assert address == post.address
+end
+
+test "allows for hash operations" do
+  address = { "address1" => "#123", "city" => "Singapore", "country" => "SG"}
+  post = Post.create(:address => address)
+
+  assert ["address1", "city", "country"] == post.address.keys
+  assert ["#123", "Singapore", "SG"] == post.address.values
+
+  post = Post[post.id]
+  assert ["address1", "city", "country"] == post.address.keys
+  assert ["#123", "Singapore", "SG"] == post.address.values
+end
+
+test "handles mutation" do
+  address = { "address1" => "#123", "city" => "Singapore", "country" => "SG"}
+  post = Post.create(:address => address)
+
+  post.address["address1"] = "#456"
+  post.save
+
+  assert ["address1", "city", "country"] == post.address.keys
+  assert ["#456", "Singapore", "SG"] == post.address.values
+
+  post = Post[post.id]
+  assert ["address1", "city", "country"] == post.address.keys
+  assert ["#456", "Singapore", "SG"] == post.address.values
+end
+
+Address = Class.new(Struct.new(:city, :country))
+
+test "raises when trying to assign a non-hash" do
+  assert_raise TypeError do
+    Post.new(:address => [])
+  end
+
+  assert_raise TypeError do
+    Post.new(:address => Address.new)
+  end
+end
+
+test "inspecting" do
+  post = Post.create(:address => { "address1" => "#456",
+                                   "city" => "Singapore",
+                                   "country" => "SG" })
+
+  expected = %q{{"address1":"#456","city":"Singapore","country":"SG"}}
+  assert expected == post.address.inspect
+
+  post.address = 'FooBar'
+  assert %{"\\\"FooBar\\\""} == post.address.inspect
+end
+