relaxdb 0.3.5

data/spec/has_many_spec.rb

@@ -0,0 +1,202 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::HasManyProxy do
+  
+  before(:all) do
+    setup_test_db
+  end
+
+  describe "has_many" do
+
+
+    describe "target_class in the generated view" do
+      it "should infer the class name from the relationship if not supplied" do
+        view = mock(:view).as_null_object
+        RelaxDB::ViewCreator.should_receive(:has_n).with(
+          "",           # client_class
+          :foo_bars,    # relationship          
+          "FooBar",     # target_class
+          ""            # relationship_to_client
+        ).and_return view
+        klass = Class.new(RelaxDB::Document) do
+          has_many :foo_bars
+        end
+      end 
+
+      it "should use the class name if supplied" do
+        view = mock(:view).as_null_object
+        RelaxDB::ViewCreator.should_receive(:has_n).with(
+          "",         # client_class
+          :foo_bars,  # relationship          
+          "Bar",     # target_class
+          ""          # relationship_to_client
+        ).and_return view
+        klass = Class.new(RelaxDB::Document) do
+          has_many :foo_bars, :class => "Bar"
+        end
+      end 
+    end    
+    
+    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])
+        RelaxDB.bulk_save u, *u.items
+        u = RelaxDB.load u._id
+        u.items.map { |i| i.name }.sort.join.should == "i1i2"
+      end
+      
+      it "should invoke the derived properties writer" do
+        class HmsdParent < RelaxDB::Document
+          property :foo, :derived => [:zongs, lambda {|f, o| o.zongs.first.z / 2 }]
+          has_many :zongs, :class => "HmsdChild"
+        end
+        class HmsdChild < RelaxDB::Document
+          property :z
+          belongs_to :hmsd_parent
+        end
+        oz = HmsdChild.new(:z => 10)
+        op = HmsdParent.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
+          Item.view_by :user_id
+          
+          u = User.new.save
+          u.items << Item.new << Item.new    
+          u.destroy!
+          Item.by_user_id(:key => u._id).should be_empty
+        end
+
+      end  
+      
+    end
+              
+  end
+
+end

data/spec/has_one_spec.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::HasOneProxy do
+  
+  before(:each) do
+    setup_test_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/migration_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require File.join(File.dirname(__FILE__), "spec_models")
+
+describe RelaxDB::Migration do
+          
+  before(:each) do
+    @mig = RelaxDB::Migration
+    setup_test_db
+  end
+      
+  it "should yield each obj to the block and save the result" do
+    Primitives.new(:num => 5).save!
+    r = @mig.run Primitives do |p|
+      pn = Primitives.new(:num => p.num * 2)
+      [p, pn]
+    end
+    Primitives.by_num.map { |p| p.num}.should == [5, 10]
+  end
+    
+  it "should raise an exception if a save results in a conflict" do
+    op = Primitives.new.save!
+    lambda do 
+      @mig.run Primitives do |p|
+        op.save!
+        p
+      end
+    end.should raise_error(RelaxDB::UpdateConflict)
+  end
+  
+  it "should not save docs for blocks that return nil" do
+    Primitives.new.save!
+    @mig.run Primitives do |p| 
+      nil
+    end
+  end
+      
+  describe "multiple docs" do
+  
+    before(:each) do
+      ps = (1..5).map { |i| Primitives.new :num => i }
+      RelaxDB.bulk_save *ps
+      RelaxDB.db.reset_req_count
+    end
+    
+    # Note: two extra requests per paginate_view request are required
+    it "should operate on a doc set of the given size aka limit" do
+      @mig.run(Primitives, 1) { |p| p.num *= p.num; p }
+      RelaxDB.db.req_count.should == 10 + 5 * 2 
+      Primitives.by_num.map { |p| p.num }.should == [1, 4, 9, 16, 25]      
+    end
+
+    it "should operate on a doc set of default size" do
+      @mig.run(Primitives) { |p| p.num *= p.num; p }
+      RelaxDB.db.req_count.should == 2 + 1 * 2
+      Primitives.by_num.map { |p| p.num }.should == [1, 4, 9, 16, 25]      
+    end
+  
+  end
+
+  describe "#fv" do
+    it "should return valid numbers" do
+      @mig.fv("foo/bar/001_foo.rb").should == 1 
+    end
+  end
+  
+  describe ".run_all" do
+    
+    it "should save the version after each successful migration" do
+      @mig.run_all "a/b/1_", lambda {}
+      RelaxDB::MigrationVersion.version.should == 1
+    end
+
+    it "should not run those migrations whose version is less than the current version" do
+      v = RelaxDB::MigrationVersion.retrieve
+      v.version = 2
+      v.save!
+      @mig.run_all "3_", lambda {}
+      RelaxDB::MigrationVersion.version.should == 3
+    end
+    
+    it "should run those migrations whose version is greater than the current version" do
+      v = RelaxDB::MigrationVersion.retrieve
+      v.version = 2
+      v.save!
+      @mig.run_all "1_foo", lambda {}
+      RelaxDB::MigrationVersion.version.should == 2
+    end
+    
+    it "should raise an exception on failure" do
+      lambda do
+        @mig.run_all "1_foo", lambda { raise "Expected" }
+      end.should raise_error(RuntimeError, "Expected")
+    end
+    
+  end
+  
+end

data/spec/migration_version_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require File.join(File.dirname(__FILE__), "spec_models")
+
+describe RelaxDB::MigrationVersion do
+  
+  before(:each) do
+    setup_test_db
+  end
+  
+  it "should not exist in a clean db" do
+    RelaxDB.load(RelaxDB::MigrationVersion::DOC_ID).should be_nil
+  end
+  
+  it "should return zero when it doesnt exist" do
+    RelaxDB::MigrationVersion.version.should == 0
+  end
+  
+  it "should autosave on retrieval when when it doesnt exist" do
+    RelaxDB::MigrationVersion.version
+    RelaxDB.load(RelaxDB::MigrationVersion::DOC_ID).should be
+  end
+  
+  it "should return the saved version" do
+    RelaxDB::MigrationVersion.update 10
+    RelaxDB::MigrationVersion.version.should == 10
+  end
+  
+end