simply_stored 0.3.9 → 0.5.0

data/test/has_and_belongs_to_many_test.rb

@@ -0,0 +1,639 @@
+require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
+
+class HasAndBelongsToManyTest < Test::Unit::TestCase
+  context "has_and_belongs_to_many" do
+    setup do
+      CouchPotato::Config.database_name = 'simply_stored_test'
+      recreate_db
+    end
+
+    context "with has_and_belongs_to_many" do
+      should "create a fetch method for the associated objects" do
+        server = Server.new
+        assert server.respond_to?(:networks)
+
+        network = Network.new
+        assert network.respond_to?(:servers)
+      end
+
+       should "raise an error if another property with the same name already exists" do
+        assert_raise(RuntimeError) do
+          class ::DoubleHasAdnBelongsToManyServer
+            include SimplyStored::Couch
+            property :other_users
+            has_and_belongs_to_many :other_users
+          end
+        end
+      end
+
+      should "fetch the associated objects" do
+        network = Network.create(:klass => "A")
+        3.times {
+          server = Server.new
+          server.network_ids = [network.id]
+          server.save!
+        }
+        assert_equal 3, network.servers.size
+      end
+
+      should "fetch the associated objects from the other side of the relation" do
+        network = Network.create(:klass => "A")
+        3.times {
+          server = Server.new
+          server.network_ids = [network.id]
+          server.save!
+        }
+        assert_equal 1, Server.first.networks.size
+      end
+
+      should "set the parent object on the clients cache" do
+        Network.expects(:find).never
+        network = Network.create(:klass => "A")
+        3.times {
+          server = Server.new
+          server.add_network(network)
+        }
+        assert_equal network, network.servers.first.networks.first
+      end
+
+      should "set the parent object on the clients cache from the other side of the relation" do
+        Server.expects(:find).never
+        network = Network.create(:klass => "A")
+        3.times {
+          server = Server.new
+          network.add_server(server)
+        }
+        assert_equal network, network.servers.first.networks.first
+      end
+
+      should "work relations from both sides" do
+        network_a = Network.create(:klass => "A")
+        network_b = Network.create(:klass => "B")
+        3.times {
+          server = Server.new
+          server.add_network(network_a)
+          server.add_network(network_b)
+        }
+        assert_equal 3, network_a.servers.size
+        network_a.servers.each do |server|
+          assert_equal 2, server.networks.size
+        end
+        assert_equal 3, network_b.servers.size
+        network_b.servers.each do |server|
+          assert_equal 2, server.networks.size
+        end
+      end
+
+      should "work relations from both sides - regardless from where the add was called" do
+        network_a = Network.create(:klass => "A")
+        network_b = Network.create(:klass => "B")
+        3.times {
+          server = Server.new
+          network_a.add_server(server)
+          network_b.add_server(server)
+        }
+        assert_equal 3, network_a.servers.size
+        network_a.servers.each do |server|
+          assert_equal 2, server.networks.size, server.network_ids.inspect
+        end
+        assert_equal 3, network_b.servers.size
+        network_b.servers.each do |server|
+          assert_equal 2, server.networks.size
+        end
+      end
+
+      context "limit" do
+
+        should "be able to limit the result set" do
+          network = Network.create(:klass => "A")
+          3.times {
+            server = Server.new
+            server.add_network(network)
+          }
+          assert_equal 2, network.servers(:limit => 2).size
+        end
+
+        should "use the given options in the cache-key" do
+          network = Network.create(:klass => "A")
+          3.times {
+            server = Server.new
+            server.add_network(network)
+          }
+          assert_equal 2, network.servers(:limit => 2).size
+          assert_equal 3, network.servers(:limit => 3).size
+        end
+
+        should "be able to limit the result set - for both directions" do
+          network_a = Network.create(:klass => "A")
+          network_b = Network.create(:klass => "B")
+          3.times {
+            server = Server.new
+            server.add_network(network_a)
+            server.add_network(network_b)
+          }
+          assert_equal 2, network_a.servers(:limit => 2).size
+          assert_equal 3, network_a.servers(:limit => 3).size
+
+          assert_equal 2, network_a.servers.first.networks(:limit => 2).size
+          assert_equal 1, network_a.servers.first.networks(:limit => 1).size
+        end
+      end
+
+      context "order" do
+        setup do
+          @network = Network.create(:klass => "A")
+          @network.created_at = Time.local(2000)
+          @network.save!
+          @network_b = Network.create(:klass => "B")
+          @network_b.created_at = Time.local(2002)
+          @network_b.save!
+          3.times do |i|
+            server = Server.new
+            server.add_network(@network)
+            server.add_network(@network_b)
+            server.created_at = Time.local(2000 + i)
+            server.save!
+          end
+        end
+
+        should "support different order" do
+          assert_nothing_raised do
+            @network.servers(:order => :asc)
+          end
+
+          assert_nothing_raised do
+            @network.servers(:order => :desc)
+          end
+        end
+
+        should "reverse the order if :desc" do
+          assert_equal @network.servers(:order => :asc).map(&:id).reverse, @network.servers(:order => :desc).map(&:id)
+          server = @network.servers.first
+          assert_equal server.networks(:order => :asc).map(&:id).reverse, server.networks(:order => :desc).map(&:id)
+        end
+
+        should "work with the limit option" do
+          server = Server.new
+          server.add_network(@network)
+          server.add_network(@network_b)
+          assert_not_equal @network.servers(:order => :asc, :limit => 3).map(&:id).reverse, @network.servers(:order => :desc, :limit => 3).map(&:id)
+          assert_not_equal server.networks(:order => :asc, :limit => 1).map(&:id).reverse, server.networks(:order => :desc, :limit => 1).map(&:id)
+        end
+      end
+
+      should "verify the given options for the accessor method" do
+        network = Network.create(:klass => "A")
+        assert_raise(ArgumentError) do
+          network.servers(:foo => :bar)
+        end
+      end
+
+      should "verify the given options for the association defintion" do
+        assert_raise(ArgumentError) do
+          Network.instance_eval do
+            has_and_belongs_to_many :foo, :bar => :do
+          end
+        end
+      end
+
+      should "only fetch objects of the correct type" do
+        network = Network.create(:klass => "A")
+        server = Server.new
+        server.network_ids = [network.id]
+        server.save!
+
+        comment = Comment.new
+        comment.network = network
+        comment.save!
+
+        assert_equal 1, network.servers.size
+      end
+
+      should "getter should user cache" do
+        network = Network.create(:klass => "A")
+        server = Server.new
+        server.network_ids = [network.id]
+        server.save!
+        network.servers
+        assert_equal [server], network.instance_variable_get("@servers")[:all]
+      end
+
+      should "add methods to handle associated objects" do
+        network = Network.create(:klass => "A")
+        assert network.respond_to?(:add_server)
+        assert network.respond_to?(:remove_server)
+        assert network.respond_to?(:remove_all_servers)
+      end
+
+      should "add methods to handle associated objects - for the other side too" do
+        server = Server.create
+        assert server.respond_to?(:add_network)
+        assert server.respond_to?(:remove_network)
+        assert server.respond_to?(:remove_all_networks)
+      end
+
+      should 'ignore the cache when requesting explicit reload' do
+        network = Network.create(:klass => "A")
+        assert_equal [], network.servers
+        server = Server.new
+        server.network_ids = [network.id]
+        server.save!
+        assert_equal [server], network.servers(:force_reload => true)
+      end
+
+      should "use the correct view when handling inheritance" do
+        network = Network.create
+        subnet = Subnet.create
+        server = Server.new
+        server.network_ids = [network.id]
+        server.save!
+        assert_equal 1, network.servers.size
+        server.update_attributes(:network_ids => nil, :subnet_ids => [subnet.id])
+        assert_equal 1, subnet.servers.size
+      end
+
+      context "when adding items" do
+        should "add the item to the internal cache" do
+          network = Network.new(:klass => "C")
+          server = Server.new
+          assert_equal [], network.servers
+          network.add_server(server)
+          assert_equal [server], network.servers
+          assert_equal [server], network.instance_variable_get("@servers")[:all]
+        end
+
+        should "raise an error when the added item is not an object of the expected class" do
+          network = Network.new
+          assert_raise(ArgumentError, 'excepted Server got String') do
+            network.add_server('foo')
+          end
+        end
+
+        should "save the added item" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+          assert !server.new_record?
+        end
+
+        should "save the added item - from both directions" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          server.add_network(network)
+          assert !server.new_record?
+        end
+
+        should 'set the forein key on the added object' do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+          assert_equal [network.id], server.network_ids
+        end
+
+        should 'set the forein key on the added object - from both directions' do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          server.add_network(network)
+          assert_equal [network.id], server.network_ids
+        end
+
+        should "adding multiple times doesn't hurt" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+          network.add_server(server)
+          server.add_network(network)
+          assert_equal [network.id], server.network_ids
+          assert_equal [network.id], Server.find(server.id).network_ids
+        end
+      end
+
+      context "when removing items" do
+        should "should unset the foreign key" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+
+          network.remove_server(server)
+          assert_equal [], server.network_ids
+        end
+
+        should "should unset the foreign key - from both directions" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+
+          server.remove_network(network)
+          assert_equal [], server.network_ids
+        end
+
+        should "remove the item from the cache" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+          assert network.servers.include?(server)
+          network.remove_server(server)
+          assert !network.servers.any?{|s| server.id == s.id}
+          assert_equal [], network.instance_variable_get("@servers")[:all]
+        end
+
+        should "remove the item from the cache - from both directions" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+          assert server.networks.include?(network)
+          server.remove_network(network)
+          assert !server.networks.any?{|n| network.id == n.id}
+          assert_equal [], server.instance_variable_get("@networks")[:all]
+        end
+
+        should "save the removed item with the nullified foreign key" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+
+          network.remove_server(server)
+          server = Server.find(server.id)
+          assert_equal [], server.network_ids
+        end
+
+        should "save the removed item with the nullified foreign key - from both directions" do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+
+          server.remove_network(network)
+          server = Server.find(server.id)
+          assert_equal [], server.network_ids
+        end
+
+        should 'raise an error when another object is the owner of the object to be removed' do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+
+          other_server = Server.create
+          assert_raise(ArgumentError) do
+            network.remove_server(other_server)
+          end
+        end
+
+        should 'raise an error when another object is the owner of the object to be removed - from both directions' do
+          server = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server)
+
+          other_network = Network.create
+          assert_raise(ArgumentError) do
+            server.remove_network(other_network)
+          end
+        end
+
+        should 'raise an error when the object is the wrong type' do
+          assert_raise(ArgumentError, 'excepted Server got String') do
+            Network.new.remove_server('foo')
+          end
+          assert_raise(ArgumentError, 'excepted Network got String') do
+            Server.new.remove_network('foo')
+          end
+        end
+      end
+
+      context "when removing all items" do
+        should 'nullify the foreign keys on all referenced items' do
+          server_1 = Server.new
+          server_2 = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server_1)
+          network.add_server(server_2)
+          network.remove_all_servers
+          server_1 = Server.find(server_1.id)
+          server_2 = Server.find(server_2.id)
+          assert_equal [], server_1.network_ids
+          assert_equal [], server_2.network_ids
+        end
+
+        should 'nullify the foreign keys on all referenced items - from both directions' do
+          server_1 = Server.new
+          server_2 = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server_1)
+          network.add_server(server_2)
+          server_1.remove_all_networks
+          server_1 = Server.find(server_1.id)
+          server_2 = Server.find(server_2.id)
+          assert_equal [], server_1.network_ids
+          assert_equal [network.id], server_2.network_ids
+        end
+
+        should 'empty the cache' do
+          server_1 = Server.new
+          server_2 = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server_1)
+          network.add_server(server_2)
+          network.remove_all_servers
+          assert_equal [], network.servers
+          assert_equal [], network.instance_variable_get("@servers")[:all]
+        end
+
+        should 'empty the cache - from both directions' do
+          server_1 = Server.new
+          server_2 = Server.new
+          network = Network.create(:klass => "A")
+          network.add_server(server_1)
+          network.add_server(server_2)
+          server_1.remove_all_networks
+          assert_equal [], server_1.networks
+          assert_equal [], server_1.instance_variable_get("@networks")[:all]
+        end
+
+        context "when counting" do
+          setup do
+            @network = Network.create(:klass => "C")
+            @server = Server.create
+          end
+
+          should "define a count method" do
+            assert @network.respond_to?(:server_count)
+            assert @server.respond_to?(:network_count)
+          end
+
+          should "cache the result" do
+            assert_equal 0, @network.server_count
+            Server.create(:network_ids => [@network.id])
+            assert_equal 0, @network.server_count
+            assert_equal 0, @network.instance_variable_get("@server_count")
+            @network.instance_variable_set("@server_count", nil)
+            assert_equal 1, @network.server_count
+          end
+
+          should "cache the result - from both directions" do
+            assert_equal 0, @server.network_count
+            @server.network_ids = [@network.id]
+            @server.save!
+            assert_equal 0, @server.network_count
+            assert_equal 0, @server.instance_variable_get("@network_count")
+            @server.instance_variable_set("@network_count", nil)
+            assert_equal 1, @server.network_count
+          end
+
+          should "force reload even if cached" do
+            assert_equal 0, @network.server_count
+            Server.create(:network_ids => [@network.id])
+            assert_equal 0, @network.server_count
+            assert_equal 1, @network.server_count(:force_reload => true)
+          end
+
+          should "force reload even if cached - from both directions" do
+            assert_equal 0, @server.network_count
+            @server.network_ids = [@network.id]
+            @server.save!
+            assert_equal 0, @server.network_count
+            assert_equal 1, @server.network_count(:force_reload => true)
+          end
+
+          should "count the number of belongs_to objects" do
+            assert_equal 0, @network.server_count(:force_reload => true)
+            Server.create(:network_ids => [@network.id])
+            assert_equal 1, @network.server_count(:force_reload => true)
+            Server.create(:network_ids => [@network.id])
+            assert_equal 2, @network.server_count(:force_reload => true)
+            Server.create(:network_ids => [@network.id])
+            assert_equal 3, @network.server_count(:force_reload => true)
+          end
+
+          should "count the number of belongs_to objects - from both directions" do
+            assert_equal 0, @server.network_count(:force_reload => true)
+            @server.network_ids = [@network.id]
+            @server.save!
+            assert_equal 1, @server.network_count(:force_reload => true)
+            @server.network_ids = [@network.id, Network.create.id]
+            @server.save!
+            assert_equal 2, @server.network_count(:force_reload => true)
+          end
+
+          should "not count non-releated objects" do
+            Server.all.each{|s| s.delete}
+            network_1 = Network.create(:klass => "A")
+            network_2 = Network.create(:klass => "B")
+            server_1 = Server.create
+            server_2 = Server.create(:network_ids => [network_1.id])
+            server_3 = Server.create(:network_ids => [network_1.id, network_2.id])
+            assert_equal 3, Server.count
+            assert_equal 2, network_1.server_count
+            assert_equal 1, network_2.server_count
+            assert_equal 0, server_1.network_count
+            assert_equal 1, server_2.network_count
+            assert_equal 2, server_3.network_count
+          end
+
+          should "not count deleted objects" do
+            network = Network.create(:klass => "A")
+            server = Server.create(:network_ids => [network.id])
+            assert_equal 1, network.server_count(:force_reload => true)
+            server.delete
+            assert_equal 0, network.server_count(:force_reload => true)
+          end
+
+          should "not count deleted objects - from both directions" do
+            network = Network.create(:klass => "A")
+            server = Server.create(:network_ids => [network.id])
+            assert_equal 1, server.network_count(:force_reload => true)
+            network.delete
+            assert_equal 0, server.network_count(:force_reload => true)
+          end
+
+        end
+      end
+
+      context "with deleted" do
+        should "not fetch deleted objects" do
+          network = Network.create(:klass => "A")
+          server = Server.new
+          server.network_ids = [network.id]
+          server.save!
+          assert_equal 1, network.servers(:force_reload => true).size
+          assert_no_difference "Network.count" do
+            assert_difference "Server.count", -1 do
+              server.delete
+            end
+          end
+          assert_equal 0, network.servers(:force_reload => true).size
+        end
+
+        should "not fetch deleted objects - from both directions" do
+          network = Network.create(:klass => "A")
+          server = Server.new
+          server.network_ids = [network.id]
+          server.save!
+          assert_equal 1, server.networks(:force_reload => true).size
+          assert_difference "Network.count", -1 do
+            assert_no_difference "Server.count" do
+              network.delete
+            end
+          end
+          assert_equal 0, server.networks(:force_reload => true).size, server.networks(:force_reload => true).inspect
+          assert_equal [], server.reload.network_ids
+        end
+      end
+
+
+      context "with soft deleted" do
+
+        should "not load soft deleted - items storing keys" do
+          network = Network.create
+          router = Router.new
+          network.add_router(router)
+          assert_equal 1, network.routers.size
+          router.delete
+          assert_equal 0, Router.count
+          assert_equal 1, Router.count(:with_deleted => true)
+          assert_equal 0, network.routers(:force_reload => true).size
+          assert_equal 1, network.routers(:force_reload => true, :with_deleted => true).size
+          router.delete!
+          assert_equal 0, network.routers(:force_reload => true, :with_deleted => true).size
+        end
+
+        should "not count soft deleted - items storing keys" do
+          network = Network.create
+          router = Router.new
+          network.add_router(router)
+          assert_equal 1, network.routers.size
+          router.delete
+          assert_equal 0, Router.count
+          assert_equal 1, Router.count(:with_deleted => true)
+          assert_equal 0, network.router_count(:force_reload => true)
+          assert_equal 1, network.router_count(:force_reload => true, :with_deleted => true)
+          router.delete!
+          assert_equal 0, network.router_count(:force_reload => true, :with_deleted => true)
+        end
+
+        should "not load soft deleted - items not storing keys: not supported" do
+          book = Book.create
+          author = Author.create
+          author.add_book(book)
+          author.delete
+          assert_equal 0, Author.count
+          assert_equal 1, Author.count(:with_deleted => true)
+          assert_equal 0, book.authors(:force_reload => true).size
+          assert_equal 0, book.authors(:force_reload => true, :with_deleted => true).size
+        end
+
+        should "not count soft deleted - items not storing keys: not supported" do
+          book = Book.create
+          author = Author.create
+          author.add_book(book)
+          author.delete
+          assert_equal 0, Author.count
+          assert_equal 1, Author.count(:with_deleted => true)
+          assert_equal 0, book.author_count(:force_reload => true)
+          assert_equal 0, book.author_count(:force_reload => true, :with_deleted => true)
+        end
+
+      end
+
+    end
+  end
+end

data/test/{couchdb/couch_has_many_test.rb → has_many_test.rb}

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require File.expand_path(File.dirname(__FILE__) + '/../fixtures/couch')
+require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
 
-class CouchHasManyTest < Test::Unit::TestCase
+class HasManyTest < Test::Unit::TestCase
   context "has_many" do
     setup do
       CouchPotato::Config.database_name = 'simply_stored_test'
@@ -13,6 +13,16 @@ class CouchHasManyTest < Test::Unit::TestCase
         user = User.new
         assert user.respond_to?(:posts)
       end
+
+       should "raise an error if another property with the same name already exists" do
+        assert_raise(RuntimeError) do
+          class ::DoubleHasManyUser
+            include SimplyStored::Couch
+            property :other_users
+            has_many :other_users
+          end
+        end
+      end
       
       should "fetch the associated objects" do
         user = User.create(:title => "Mr.")

data/test/{couchdb/couch_has_one_test.rb → has_one_test.rb}

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require File.expand_path(File.dirname(__FILE__) + '/../fixtures/couch')
+require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
 
-class CouchHasOneTest < Test::Unit::TestCase
+class HasOneTest < Test::Unit::TestCase
   context "with has_one" do
     setup do
       CouchPotato::Config.database_name = 'simply_stored_test'
@@ -11,6 +11,16 @@ class CouchHasOneTest < Test::Unit::TestCase
     should "add a getter method" do
       assert Instance.new.respond_to?(:identity)
     end
+
+    should "raise an error if another property with the same name already exists" do
+      assert_raise(RuntimeError) do
+        class ::DoubleHasOneUser
+          include SimplyStored::Couch
+          property :user
+          has_one :user
+        end
+      end
+    end
     
     should "fetch the object when invoking the getter" do
       instance = Instance.create