ceritium-relaxdb 0.2.8

data/spec/has_many_spec.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::HasManyProxy do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+
+  describe "has_many" do
+    
+    it "should be considered enumerable" do
+      u = User.new.save
+      u.items.should be_a_kind_of(Enumerable)
+    end
+    
+    it "should actually be enumerable" do
+      u = User.new.save
+      u.items << Item.new(:name => "a")
+      u.items << Item.new(:name => "b")
+      names = u.items.inject("") { |memo, i| memo << i.name }
+      names.should == "ab"
+    end
+    
+    it "should preserve the collection across the load / save boundary" do
+      u = User.new.save
+      u.items << Item.new
+      u = RelaxDB.load u._id
+      u.items.size.should == 1
+    end    
+    
+    it "should work with MultiWordClassNames" do
+      c = MultiWordChild.new
+      m = MultiWordClass.new.save
+      m.multi_word_children << c
+      m = RelaxDB.load m._id
+      m.multi_word_children[0].should == c
+    end    
+            
+    describe "#<<" do
+
+      it "should link the added item to the parent" do
+        u = User.new
+        u.items << Item.new
+        u.items[0].user.should == u
+      end
+    
+      it "should return self" do
+        u = User.new.save
+        u.items << Item.new << Item.new
+        u.items[0].user.should == u
+        u.items[1].user.should == u
+      end
+      
+      it "should not created duplicates when invoked with same object more than once" do
+        u = User.new.save
+        i = Item.new
+        u.items << i << i
+        u.items.size.should == 1
+      end
+      
+      it "should return false when the child fails validation" do
+        d = Dysfunctional.new
+        r = (d.failures << Failure.new)
+        r.should be_false
+        d.failures.should be_empty
+      end
+              
+    end
+    
+    describe "#=" do
+      
+      before(:each) do
+        # Create the underlying views
+        User.new(:items => [], :invites_received => [], :invites_sent => [])
+      end
+      
+      it "should not attempt to save the child objects when the relationship is established" do
+        RelaxDB.db.put_count = 0
+        i1, i2 = Item.new(:name => "i1"), Item.new(:name => "i2")
+        User.new(:items => [i1, i2])
+        RelaxDB.db.put_count.should == 0
+      end
+      
+      it "should preserve given relationships across save/load boundary" do
+        i1, i2 = Item.new(:name => "i1"), Item.new(:name => "i2")
+        u = User.new(:items => [i1, i2])
+        u.save_all!
+        u = RelaxDB.load u._id
+        u.items.map { |i| i.name }.sort.join.should == "i1i2"
+      end
+      
+      it "should invoke the derived properties writer" do
+        P = Class.new(RelaxDB::Document) do
+          property :foo, :derived => [:zongs, lambda {|f, o| o.zongs.first.z / 2 }]
+          has_many :zongs, :class => "Zong"
+        end
+        Zong = Class.new(RelaxDB::Document) do
+          property :z
+          belongs_to :p
+        end
+        oz = Zong.new(:z => 10)
+        op = P.new(:zongs => [oz])
+        op.foo.should == 5
+      end
+      
+    end
+
+    describe "#delete" do
+    
+      it "should nullify the belongs_to relationship" do
+        u = User.new.save
+        i = Item.new
+        u.items << i
+        u.items.delete i
+        i.user.should be_nil 
+        RelaxDB.load(i._id).user.should be_nil
+      end
+    
+    end
+    
+    describe "#clear" do
+    
+      it "should result in an empty collection" do
+        u = User.new.save
+        u.items << Item.new << Item.new
+        u.items.clear
+        u.items.should be_empty
+      end
+
+      it "should nullify all child relationships" do
+        u = User.new.save
+        i1, i2 = Item.new, Item.new
+        u.items << i1
+        u.items << i2
+        u.items.clear
+
+        i1.user.should be_nil
+        i2.user.should be_nil
+        RelaxDB.load(i1._id).user.should be_nil
+        RelaxDB.load(i2._id).user.should be_nil
+      end
+    
+    end
+        
+    describe "owner" do
+    
+      it "should be able to form multiple relationships with the same class of child" do
+        u1, u2 = User.new.save, User.new.save
+        i = Invite.new(:recipient => u2)
+        u1.invites_sent << Invite.new
+        RelaxDB.load(u1._id).invites_sent[0] == i
+        RelaxDB.load(u2._id).invites_received[0] == i
+      end
+      
+      describe "#destroy" do
+
+        it "should nullify its child relationships" do
+          u = User.new.save
+          u.items << Item.new << Item.new    
+          u.destroy!
+          Item.all.sorted_by(:user_id) { |q| q.key(u._id) }.should be_empty
+        end
+
+      end  
+      
+    end
+              
+  end
+
+end

data/spec/has_one_spec.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::HasOneProxy do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+        
+  describe "has_one" do
+    
+    it "should return nil when accessed before assignment" do
+      p = Photo.new
+      p.rating.should == nil
+    end    
+    
+    it "should be establishable via a constructor attribute" do
+      r = Rating.new
+      p = Photo.new :rating => r
+      p.rating.should == r
+    end
+
+    it "should be establishable via assignment" do
+      p = Photo.new
+      r = Rating.new
+      p.rating = r
+      p.rating.should == r
+    end
+    
+    it "should return the same object on repeated invocations" do
+      p = Photo.new.save
+      p.rating = Rating.new
+      p = RelaxDB.load(p._id)
+      p.rating.object_id.should == p.rating.object_id
+    end
+    
+    it "should be preserved across load / save boundary" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      p = RelaxDB.load p._id
+      p.rating.should == r
+    end    
+    
+    it "should be able reference itself via its child" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      p = RelaxDB.load p._id
+      p.rating.photo.should == p
+    end        
+    
+    it "should work with MultiWordClassNames" do
+      c = MultiWordChild.new
+      m = MultiWordClass.new(:multi_word_child => c).save
+      m = RelaxDB.load m._id
+      m.multi_word_child.should == c
+    end
+           
+    describe "#=" do
+
+      it "should create a reference from the child to the parent" do
+        p = Photo.new
+        r = Rating.new
+        p.rating = r
+        r.photo.should == p
+      end
+
+      it "should save the assigned object" do
+        p = Photo.new
+        r = Rating.new
+        p.rating = r
+        r.should_not be_unsaved
+      end
+
+      it "will not save the parent" do
+        p = Photo.new
+        r = Rating.new
+        p.rating = r
+        p.should be_unsaved
+      end
+
+      it "should set the target to nil when nil is assigned" do
+        p = Photo.new
+        p.rating = nil
+        p.rating.should be_nil
+      end
+
+      it "should nullify any existing relationship in the database" do
+        p = Photo.new
+        r = Rating.new
+        p.rating = r
+        p.rating = nil
+        RelaxDB.load(r._id).photo.should be_nil
+      end
+
+      it "should nullify any existing relationship on a known in-memory object" do
+        p = Photo.new
+        r = Rating.new
+        p.rating = r
+        p.rating = nil
+        r.photo.should be_nil
+      end
+
+      it "will not nullify any existing relationship on unknown in-memory objects" do
+        p = Photo.new.save
+        r = Rating.new
+        p.rating = r
+        r_copy = RelaxDB.load(r._id)
+        p.rating = nil
+        r_copy.photo.should_not be_nil
+      end
+      
+      it "will not throw an error when the rhs fails validation" do
+        d = Dysfunctional.new.save
+        f = Failure.new
+        d.failure = f
+        d.failure.should == f
+      end
+
+    end  
+           
+  end
+      
+end

data/spec/query_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::Query do
+
+  describe "#view_name" do
+
+    it "should match a single key attribute" do
+      q = RelaxDB::SortedByView.new("", :foo)
+      q.view_name.should == "all_sorted_by_foo"
+    end
+    
+    it "should match key attributes" do
+      q = RelaxDB::SortedByView.new("", :foo, :bar)
+      q.view_name.should == "all_sorted_by_foo_and_bar"
+    end
+  end
+  
+  describe "#view_path" do
+    
+    it "should list design document and view name" do
+      q = RelaxDB::Query.new("Zenith", "mount")
+      q.view_path.should == "_design/Zenith/_view/mount"
+    end
+    
+    it "should contain URL and JSON encoded key when the key has been set" do
+      q = RelaxDB::Query.new("", "")
+      q.key("olympus")
+      q.view_path.should == "_view//?key=%22olympus%22"
+    end
+    
+    it "should honour startkey, endkey and limit" do
+      q = RelaxDB::Query.new("", "")
+      q.startkey(["olympus"]).endkey(["vesuvius", 3600]).limit(100)
+      q.view_path.should == "_view//?startkey=%5B%22olympus%22%5D&endkey=%5B%22vesuvius%22%2C3600%5D&limit=100"
+    end
+        
+    it "should specify a null key if key was set to nil" do
+      q = RelaxDB::Query.new("", "")
+      q.key(nil)
+      q.view_path.should == "_view//?key=null"
+    end
+
+    it "should specify a null startkey if startkey was set to nil" do
+      q = RelaxDB::Query.new("", "")
+      q.startkey(nil)
+      q.view_path.should == "_view//?startkey=null"
+    end
+
+    it "should specify a null endkey if endkey was set to nil" do
+      q = RelaxDB::Query.new("", "")
+      q.endkey(nil)
+      q.view_path.should == "_view//?endkey=null"
+    end
+    
+    it "should not JSON encode the startkey_docid" do
+      q = RelaxDB::Query.new("", "")
+      q.startkey_docid("foo")
+      q.view_path.should == "_view//?startkey_docid=foo"
+    end
+
+    it "should not JSON encode the endkey_docid" do
+      q = RelaxDB::Query.new("", "")
+      q.endkey_docid("foo")
+      q.view_path.should == "_view//?endkey_docid=foo"
+    end
+    
+  end  
+  
+  describe "#keys" do
+    
+    it "should return a JSON encoded hash" do
+      q = RelaxDB::Query.new("", "")
+      q.keys(["a", "b"])
+      q.keys.should == '{"keys":["a","b"]}'
+    end
+    
+  end
+      
+end

data/spec/references_many_spec.rb

@@ -0,0 +1,178 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::ReferencesManyProxy do
+
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+
+  describe "references_many" do
+        
+    it "should preserve the relationships across the save / load boundary" do
+      p = Photo.new
+      t = Tag.new
+      t.photos << p
+    
+      p = RelaxDB.load p._id
+      p.tags.size.should == 1
+      p.tags[0].should == t
+
+      t = RelaxDB.load t._id
+      t.photos.size.should == 1
+      t.photos[0].should == p
+    end
+    
+    it "should issue only a single request to resolve the relationship" do
+      p, t = Photo.new, Tag.new
+      p.tags << t
+      
+      # Create the views
+      p.tags.map { |t| t._id }
+      
+      p = RelaxDB.load p._id      
+      RelaxDB.db.get_count = 0
+      p.tags.map { |t| t._id }
+      p.tags.map { |t| t._id }
+      RelaxDB.db.get_count.should == 1
+    end
+    
+    it "should not resolve the relationship when an object is instantiated" do
+      p, t = Photo.new, Tag.new
+      p.tags << t
+
+      RelaxDB.db.get_count = 0
+      p = RelaxDB.load p._id      
+      RelaxDB.db.get_count.should == 1
+    end
+    
+    it "should make the ids available as a property" do
+      p, t = Photo.new, Tag.new
+      p.tags << t
+      
+      p.tags_ids.should == [t._id]
+    end
+      
+    describe "#=" do
+      it "should not be invoked" do
+      end
+    end
+      
+    describe "#<<" do
+      
+      it "should set the relationship on both sides" do
+        p = Photo.new(:name => "photo")
+        t = Tag.new(:name => "tag")
+        p.tags << t
+    
+        p.tags.size.should == 1
+        p.tags[0].name.should == "tag"
+    
+        t.photos.size.should == 1
+        t.photos[0].name.should == "photo"
+      end
+      
+      it "should not create duplicates when the same object is added more than once" do
+        p = Photo.new
+        t = Tag.new
+        p.tags << t << t
+        p.tags.size.should == 1
+      end      
+      
+      it "should not create duplicates when reciprocal objects are added from opposite sides" do
+        p = Photo.new
+        t = Tag.new
+        p.tags << t
+        t.photos << p
+        p.tags.size.should == 1
+        t.photos.size.should == 1
+      end
+      
+      it "will resolve the reciprocal relationship" do
+        # Create the views
+        p, t = Photo.new, Tag.new
+        p.tags << t
+        
+        p, t = Photo.new, Tag.new
+        RelaxDB.db.get_count = 0
+        p.tags << t
+        RelaxDB.db.get_count.should == 2
+      end      
+
+    end
+
+    describe "#delete" do
+
+      it "should nullify relationship on both sides" do
+        p = Photo.new
+        t = Tag.new
+        p.tags << t
+
+        p.tags.delete(t)
+        p.tags.should be_empty
+        t.photos.should be_empty
+      end
+      
+    end
+    
+    describe "owner#destroy" do
+      
+      it "should remove its membership from its peers in memory" do
+        p = Photo.new
+        t = Tag.new
+        p.tags << t
+
+        p.destroy!
+        t.photos.size.should == 0
+      end
+
+      it "should remove its membership from its peers in CouchDB" do
+        p = Photo.new
+        t = Tag.new
+        p.tags << t
+
+        p.destroy!
+        RelaxDB.load(t._id).photos.should be_empty
+      end
+      
+    end  
+    
+    # Leaving this test as a reminder of problems with all.destroy and a self referential 
+    # references_many
+    #
+    # This test more complex than it needs to be to prove the point
+    # It also serves as a proof of a self referential references_many, but there are better places for that
+    # it "all.destroy should play nice with self referential references_many" do
+    #   u1 = TwitterUser.new(:name => "u1")
+    #   u2 = TwitterUser.new(:name => "u2")
+    #   u3 = TwitterUser.new(:name => "u3")
+    #   
+    #   u1.followers << u2
+    #   u1.followers << u3
+    #   u3.leaders << u2
+    #   
+    #   u1f = u1.followers.map { |u| u.name }
+    #   u1f.sort.should == ["u2", "u3"]
+    #   u1.leaders.should be_empty
+    #   
+    #   u2.leaders.size.should == 1
+    #   u2.leaders[0].name.should == "u1"
+    #   u2.followers.size.should == 1
+    #   u2.followers[0].name.should == "u3"
+    #   
+    #   u3l = u3.leaders.map { |u| u.name }
+    #   u3l.sort.should == ["u1", "u2"]
+    #   u3.followers.should be_empty
+    #   
+    #   TwitterUser.all.destroy!
+    #   TwitterUser.all.should be_empty
+    # end
+          
+  end
+
+end