yssk22-couch_resource 0.1.0

data/test/test_callbacks.rb

@@ -0,0 +1,115 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), "../lib/couch_resource")
+TEST_DB_PATH  = "/couch_resource_callback_test"
+
+class CallbackOrderTest < CouchResource::Base
+  self.database = "http://localhost:5984/#{TEST_DB_PATH}"
+  string :title
+  def callback_orders
+    @callback_orders ||= []
+  end
+  CouchResource::Callbacks::CALLBACKS.each do |callback|
+    module_eval "def #{callback}; callback_orders << :#{callback}; end"
+  end
+end
+
+class StopCallbackTest < CouchResource::Base
+  self.database = "http://localhost:5984/#{TEST_DB_PATH}"
+  string :stopper_method
+  def called_callbacks
+    @called_callbacks ||= []
+  end
+  [:before_validation, :before_validation_on_create, :before_validation_on_update,
+   :before_save,       :before_create, :before_update, :before_destroy].each do |callback|
+    module_eval <<-EOS
+     def #{callback};
+       called_callbacks << :#{callback}
+       return false if self.stopper_method.to_s == "#{callback}"
+     end
+EOS
+
+  end
+
+end
+
+class TestValidations < Test::Unit::TestCase
+  def setup
+    res = CallbackOrderTest.connection.put(CallbackOrderTest.database.path)
+    unless res[:ok]
+      puts "Failed to create test database. Check couchdb server running."
+    end
+  end
+
+  def teardown
+    res = CallbackOrderTest.connection.delete(CallbackOrderTest.database.path)
+    unless res[:ok]
+      puts "Failed to drop test database. Delete manually before you test next time."
+    end
+  end
+
+  def test_callback_order
+    obj = CallbackOrderTest.new
+
+    # after_initialize
+    assert_equal [:after_initialize], obj.callback_orders
+    obj.callback_orders.clear
+
+    # validate and save callbacks
+    obj.title = "hoge"
+    assert obj.save
+    assert_not_nil obj.callback_orders
+    assert_equal [:before_validation, :before_validation_on_create,
+                  :after_validation,  :after_validation_on_create,
+                  :before_save,       :before_create,
+                  :after_create,      :after_save],  obj.callback_orders
+    obj.callback_orders.clear
+    assert obj.save
+    assert_equal [:before_validation, :before_validation_on_update,
+                  :after_validation,  :after_validation_on_update,
+                  :before_save,       :before_update,
+                  :after_update,      :after_save],  obj.callback_orders
+    obj.callback_orders.clear
+
+    # after_find
+    obj2 = CallbackOrderTest.find(obj.id)
+    assert_equal [:after_initialize, :after_find], obj2.callback_orders
+    obj2.callback_orders.clear
+
+    # destroy
+    assert obj.destroy
+    assert_equal [:before_destroy, :after_destroy],  obj.callback_orders
+  end
+
+  def test_stop_callback
+    obj = StopCallbackTest.new
+
+    befores = [:before_validation, :before_validation_on_create,
+               :before_save,       :before_create]
+
+    befores.each_with_index do |stopper, index|
+      obj.stopper_method = stopper
+      assert !obj.save, "unexpected saving not working stopper (#{stopper})"
+      assert_equal befores[0..index], obj.called_callbacks
+      obj.called_callbacks.clear
+    end
+
+    obj.stopper_method = nil
+    assert obj.save
+    obj.called_callbacks.clear
+
+    befores = [:before_validation, :before_validation_on_update,
+               :before_save,       :before_update]
+    befores.each_with_index do |stopper, index|
+      obj.stopper_method = stopper
+      assert !obj.save, "unexpected saving not working stopper (#{stopper})"
+      assert_equal befores[0..index], obj.called_callbacks
+      obj.called_callbacks.clear
+    end
+
+    obj.called_callbacks.clear
+    obj.stopper_method = :before_destroy
+    assert !obj.destroy
+    assert_not_nil obj.rev
+    assert_equal [:before_destroy],  obj.called_callbacks
+  end
+end

data/test/test_connection.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), "../lib/couch_resource/connection")
+
+TEST_DB_PATH  = "/couch_resource_connection_test"
+
+class TestStruct < Test::Unit::TestCase
+  def setup
+    @connection = CouchResource::Connection.new("http://localhost:5984")
+    begin
+      res = @connection.put(TEST_DB_PATH)
+    rescue CouchResource::ResourceConflict, CouchResource::PreconditionFailed => e
+      @connection.delete(TEST_DB_PATH)
+      retry
+    end
+  end
+
+  def test_get
+    res = @connection.get("/")
+    assert_not_nil   res[:couchdb]
+    assert_equal "Welcome", res[:couchdb]
+  end
+
+  def test_normalize_hash
+    res = @connection.post(TEST_DB_PATH, {
+                             :a => {:b => { :c => [1,2,3]}}
+                           }.to_json)
+    assert_not_nil res[:id]
+    id = res[:id]
+    res = @connection.get(File.join(TEST_DB_PATH, id))
+    assert_not_nil res[:_id]
+    assert_not_nil res[:a]
+    assert_not_nil res[:a][:b]
+    assert_not_nil res[:a][:b][:c]
+    assert_not_nil res["_id"]
+    assert_not_nil res["a"]
+    assert_not_nil res["a"]["b"]
+    assert_not_nil res["a"]["b"]["c"]
+  end
+end

data/test/test_struct.rb

@@ -0,0 +1,332 @@
+require 'test/unit'
+
+require File.join(File.dirname(__FILE__), "../lib/couch_resource/struct")
+
+class StringTest
+  include CouchResource::Struct
+  string :member
+  string :nillable_member, :allow_nil => true
+end
+
+class NumberTest
+  include CouchResource::Struct
+  number :member
+end
+
+class BooleanTest
+  include CouchResource::Struct
+  boolean :member
+end
+
+class ArrayTest
+  include CouchResource::Struct
+  array :member
+end
+
+class ObjectTest
+  include CouchResource::Struct
+  object :member
+end
+
+class CollectionTest
+  include CouchResource::Struct
+  class NestedClass
+    include CouchResource::Struct
+    string :member
+  end
+  collection :member, :each => NestedClass
+end
+
+class NestedObjectTest
+  include CouchResource::Struct
+  class NestedClass
+    include CouchResource::Struct
+    object :member
+  end
+  object :nest, :is_a => NestedClass
+end
+
+class DateTimeTest
+  include CouchResource::Struct
+  datetime :member
+end
+
+
+class TestStruct < Test::Unit::TestCase
+  def test_string
+    obj = StringTest.new
+    # test attribute (with implicit type conversion)
+    obj.member = "hogehoge"
+    assert_equal "hogehoge", obj.member
+    obj.member = 1
+    assert_equal "1", obj.member
+    obj.member = true
+    assert_equal "true", obj.member
+    obj.member = [1,2,3]
+    assert_equal "123", obj.member
+    obj.member = { :hoge => :fuga }
+    assert_equal "hogefuga", obj.member
+
+    # test to_hash
+    obj.member = "hogehoge"
+    assert_equal({ "class" => "StringTest",
+                   "member" => "hogehoge",
+                   "nillable_member" => nil},
+                 obj.to_hash)
+
+    # test from_hash
+    assert_equal obj.member, StringTest.from_hash(obj.to_hash).member
+
+    # test allow_nil
+    obj.nillable_member = "a"
+    assert_equal "a", obj.nillable_member
+    obj.nillable_member = nil
+    assert_nil obj.nillable_member
+    obj.nillable_member = false
+    assert_nil obj.nillable_member
+
+  end
+
+  def test_number
+    obj = NumberTest.new
+    # test attribute (with implicit type conversion)
+    obj.member = 10
+    assert_equal 10, obj.member
+    obj.member = 10.1
+    assert_equal 10.1, obj.member
+    obj.member = "hogehoge"
+    assert_equal 0, obj.member
+    obj.member = "111"
+    assert_equal 111, obj.member
+    obj.member = true
+    assert_equal 0, obj.member
+    obj.member = [1,2,3]
+    assert_equal 123, obj.member    # because [1,2,3] (to_s) =>  "123" (to_i) =>
+    obj.member = { :hoge => :fuga }
+    assert_equal 0, obj.member
+
+
+    # test to_hash
+    obj.member = 10
+    assert_equal({"class" => "NumberTest", "member" => 10},
+                 obj.to_hash)
+
+    # test from_hash
+    assert_equal obj.member, NumberTest.from_hash(obj.to_hash).member
+  end
+
+  def test_boolean
+    obj = BooleanTest.new
+    # test attribute (with implicit type conversion)
+    obj.member = true
+    assert obj.member
+    assert obj.member?
+    obj.member = 10
+    assert_equal true, obj.member
+    obj.member = 10.1
+    assert_equal true, obj.member
+    obj.member = "hogehoge"
+    assert_equal true, obj.member
+    obj.member = "111"
+    assert_equal true, obj.member
+    obj.member = [1,2,3]
+    assert_equal true, obj.member    # because [1,2,3] (to_s) =>  "123" (to_i) =>
+    obj.member = { :hoge => :fuga }
+    assert_equal true, obj.member
+    obj.member = false
+    assert !obj.member
+    assert !obj.member?
+
+    # test to_hash
+    obj.member = true
+    assert_equal({"class" => "BooleanTest", "member" => true},
+                 obj.to_hash)
+    # test from_hash
+    assert_equal obj.member, BooleanTest.from_hash(obj.to_hash).member
+
+    obj.member = false
+    assert_equal({"class" => "BooleanTest", "member" => false},
+                 obj.to_hash)
+    # test from_hash
+    assert_equal obj.member, BooleanTest.from_hash(obj.to_hash).member
+
+
+
+  end
+
+  def test_array
+    obj = ArrayTest.new
+    # test attribute (with implicit type conversion)
+    obj.member = []
+    assert_equal [], obj.member
+    obj.member = 10
+    assert_equal [10], obj.member
+    obj.member = 10.1
+    assert_equal [10.1], obj.member
+    obj.member = "hogehoge"
+    assert_equal ["hogehoge"], obj.member
+    obj.member = [1,2,3]
+    assert_equal [1,2,3], obj.member    # because [1,2,3] (to_s) =>  "123" (to_i) =>
+    obj.member = { :hoge => :fuga }
+    assert_equal [[:hoge , :fuga]] , obj.member
+
+    # test to_hash
+    obj.member = []
+    assert_equal({"class" => "ArrayTest", "member" => []},
+                 obj.to_hash)
+    assert_equal obj.member, ArrayTest.from_hash(obj.to_hash).member
+
+    # test from_hash
+    obj.member = "hoge"
+    assert_equal ["hoge"], obj.member
+    assert_equal({"class" => "ArrayTest", "member" => ["hoge"]},
+                 obj.to_hash)
+    assert_equal obj.member, ArrayTest.from_hash(obj.to_hash).member
+  end
+
+  def test_collection
+    obj = CollectionTest.new
+    # test attribute (with implicit type conversion)
+    obj.member = []
+    assert_equal [], obj.member
+    obj.member = 10
+    assert_equal [], obj.member
+    obj.member = 10.1
+    assert_equal [], obj.member
+    obj.member = "hogehoge"
+    assert_equal [], obj.member
+    obj.member = [1,2,3]
+    assert_equal [], obj.member    # because [1,2,3] (to_s) =>  "123" (to_i) =>
+    obj.member = { :hoge => :fuga }
+    assert_equal [] , obj.member
+
+    obj.member = []
+    obj.member << CollectionTest::NestedClass.from_hash({:member => "hoge"})
+
+    assert_equal "hoge", obj.member.first.member
+
+    #obj.member = []
+    #obj.member << {:member => "hoge"}
+
+    # test to_hash
+    obj.member = []
+    assert_equal({"class" => "CollectionTest", "member" => []},
+                 obj.to_hash)
+    assert_equal obj.member, CollectionTest.from_hash(obj.to_hash).member
+
+    # test from_hash
+    obj.member = "hoge"
+    assert_equal [], obj.member
+    assert_equal({"class" => "CollectionTest", "member" => []},
+                 obj.to_hash)
+    assert_equal obj.member, CollectionTest.from_hash(obj.to_hash).member
+  end
+
+  def test_object
+    obj = ObjectTest.new
+    # test attribute (with implicit type conversion)
+    obj.member = []
+    assert_nil obj.member
+    obj.member = 10
+    assert_nil obj.member
+    obj.member = 10.1
+    assert_nil obj.member
+    obj.member = "hogehoge"
+    assert_nil obj.member
+    obj.member = [1,2,3]
+    assert_nil obj.member
+    obj.member = { "hoge" => :fuga }
+    assert_equal({ "hoge" => :fuga }, obj.member)
+
+    # test to_hash & from_hash
+    obj.member = nil
+    assert_nil obj.member
+    assert_equal({ "class" => "ObjectTest",
+                   "member" => nil
+                 }, obj.to_hash)
+    assert_equal obj.member, ObjectTest.from_hash(obj.to_hash).member
+    obj.member = {
+      :hoge => :fuga,
+      :foo  => :bar
+    }
+    assert_equal :fuga, obj.member[:hoge]
+    assert_equal :bar,  obj.member[:foo]
+    assert_equal({ "class" => "ObjectTest",
+                   "member" => {
+                     "hoge" => :fuga,
+                     "foo"  => :bar
+                   }},
+                 obj.to_hash)
+    assert_equal obj.member, ObjectTest.from_hash(obj.to_hash).member
+  end
+
+  def test_nested_object
+    obj = NestedObjectTest.new
+    assert_nil obj.nest
+    assert_equal({ "class" => "NestedObjectTest",
+                   "nest" => nil
+                 }, obj.to_hash)
+    obj.nest = NestedObjectTest::NestedClass.new
+    assert_not_nil obj.nest
+    assert_equal({ "class" => "NestedObjectTest",
+                   "nest" => {
+                     "class" => "NestedObjectTest::NestedClass",
+                     "member" => nil
+                   }
+                 }, obj.to_hash)
+    assert_equal obj.nest.member, NestedObjectTest.from_hash(obj.to_hash).nest.member
+
+    obj.nest.member = {
+      :hoge => :fuga,
+      :foo  => :bar
+    }
+    assert_equal :fuga, obj.nest.member[:hoge]
+    assert_equal :bar,  obj.nest.member[:foo]
+    assert_equal({"class" => "NestedObjectTest",
+                   "nest" => {
+                     "class" => "NestedObjectTest::NestedClass",
+                     "member" => {
+                       "hoge" => :fuga,
+                       "foo"  => :bar
+                     }
+                   }
+                 },
+                 obj.to_hash)
+    assert_equal obj.nest.member[:hoge], NestedObjectTest.from_hash(obj.to_hash).nest.member[:hoge]
+    assert_equal obj.nest.member[:foo],  NestedObjectTest.from_hash(obj.to_hash).nest.member[:foo]
+
+  end
+
+  def test_datetime
+    obj = DateTimeTest.new
+    obj.member = Time.now
+    assert_not_nil obj.member
+    obj.member = Date.today
+    assert_not_nil obj.member
+    obj.member = DateTime.now
+    assert_not_nil obj.member
+    # test attribute (with implicit type conversion)
+    obj.member = DateTime.now.to_s
+    assert_not_nil obj.member
+    obj.member = "hogehoge"
+    assert_nil obj.member
+    obj.member = 1
+    assert_nil obj.member
+    obj.member = true
+    assert_nil obj.member
+    obj.member = [1,2,3,4,5,6]
+    assert_nil obj.member
+    obj.member = { :hoge => :fuga }
+    assert_nil obj.member
+
+    # test to_hash
+    d = DateTime.now
+    obj.member = d
+    assert_equal({ "class" => "DateTimeTest",
+                   "member" => d},
+                 obj.to_hash)
+
+    # test from_hash
+    assert_equal obj.member, DateTimeTest.from_hash(obj.to_hash).member
+  end
+end