paulcarey-relaxdb 0.1.0

data/spec/document_spec.rb

@@ -0,0 +1,301 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::Document 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 ".new" do 
+    
+    it "should create an object with an id" do
+      p = Atom.new
+      p._id.should_not be_nil
+    end
+    
+    it "should create an object with a nil revision" do
+      Atom.new._rev.should be_nil
+    end
+        
+    it "should convert attributes that end in _at to dates" do
+      now = Time.now
+      p = Post.new(:viewed_at => now).save
+      p = RelaxDB.load(p._id)
+      p.viewed_at.class.should == Time
+      p.viewed_at.should be_close(now, 1)
+    end
+    
+    it "will silently ignore parameters that don't specify class attributes" do
+      # Consider this a feature or bug. It allows an object containing both request params
+      # and superflous data to be passed directly to a constructor.
+      Post.new(:foo => "").save
+    end  
+    
+  end
+      
+  describe "#to_json" do
+    
+    it "should not output nil attributes" do
+      Atom.new.to_json.should_not include("rev")
+    end
+    
+  end
+  
+  describe "#save" do
+    
+    it "should set an object's revision" do
+      p = Atom.new.save
+      p._rev.should_not be_nil
+    end
+    
+    it "should result in an object considered saved" do
+      Atom.new.save.should_not be_unsaved
+    end
+    
+    it "should be invokable multiple times" do
+      p = Atom.new
+      p.save
+      p.save      
+    end
+    
+    it "should set created_at when first saved" do
+      now = Time.now
+      created_at = Post.new.save.created_at
+      now.should be_close(created_at, 1)  
+    end
+    
+    it "should set created_at when first saved unless supplied to the constructor" do
+      back_then = Time.now - 1000
+      p = Post.new(:created_at => back_then).save
+      p.created_at.should be_close(back_then, 1)
+    end
+        
+  end
+  
+  describe "loaded objects" do
+    
+    it "should contain state as when saved" do
+      now = Time.now
+      p = Primitives.new(:str => "foo", :num => 19.30, :true_bool => true, :false_bool => false, :created_at => now).save
+      p = RelaxDB.load(p._id)
+      p.str.should == "foo"
+      p.num.should == 19.30
+      p.true_bool.should be_true
+      p.false_bool.should_not be_true
+      p.created_at.should be_close(now, 1)
+      p.empty.should be_nil
+    end
+    
+    it "should be saveable" do
+      a = Atom.new.save
+      a = RelaxDB.load(a._id)
+      a.save
+    end
+    
+  end
+  
+  describe "#destroy" do  
+    
+    it "should delete the corresponding document from CouchDB" do
+      p = Atom.new.save.destroy!
+      lambda { RelaxDB.load(p._id) }.should raise_error
+    end
+
+    it "should prevent the object from being resaved" do
+      p = Atom.new.save.destroy!
+      lambda { p.save }.should raise_error
+    end
+    
+    it "will result in undefined behaviour when invoked on unsaved objects" do
+      Photo.new.destroy!      
+      lambda { Atom.new.destroy! }.should raise_error
+    end
+  
+  end
+  
+  describe "#all.destroy!" do
+  
+    it "should delete from CouchDB all documents of the corresponding class" do
+      Atom.new.save
+      Post.new.save
+      Post.new.save
+      Post.all.destroy!
+      Post.all.should be_empty
+      Atom.all.size.should == 1
+    end
+  
+  end
+  
+  describe "==" do
+    
+    it "should define equality based on CouchDB id" do
+      i1 = Atom.new.save
+      i2 = Atom.new.save
+      i3 = RelaxDB.load(i1._id)
+      i1.should_not == i2
+      i1.should == i3
+    end
+    
+    it "should return false when passed a nil object" do
+      (Atom.new == nil).should_not be_true
+    end
+    
+  end
+  
+  describe "#all" do
+  
+    it "should return all instances of that class" do
+      Photo.new.save
+      Rating.new.save
+      Rating.new.save
+      Rating.all.size.should == 2      
+    end
+  
+    it "should return an empty array when no instances exist" do
+      Atom.all.should be_an_instance_of(Array)
+      Atom.all.should be_empty
+    end
+    
+  end
+  
+  describe "#all.sorted_by" do
+  
+    it "should sort ascending by default" do
+      Post.new(:content => "b").save
+      Post.new(:content => "a").save
+      posts = Post.all.sorted_by(:content)
+      posts[0].content.should == "a"
+      posts[1].content.should == "b"
+    end
+
+    it "should sort desc when specified" do
+      Post.new(:content => "a").save
+      Post.new(:content => "b").save
+      posts = Post.all.sorted_by(:content) { |q| q.descending(true) }
+      posts[0].content.should == "b"
+      posts[1].content.should == "a"
+    end
+  
+    it "should sort date attributes lexicographically" do
+      t = Time.new
+      Post.new(:viewed_at => t+1000, :content => "late").save
+      Post.new(:viewed_at => t, :content => "early").save
+      posts = Post.all.sorted_by(:viewed_at)
+      posts[0].content.should == "early"
+      posts[1].content.should == "late"
+    end
+    
+    describe "results" do
+
+      it "should be retrievable by exact criteria" do
+        Post.new(:subject => "foo").save
+        Post.new(:subject => "foo").save
+        Post.new(:subject => "bar").save
+        Post.all.sorted_by(:subject) { |q| q.key("foo") }.size.should == 2
+      end
+
+      it "should be retrievable by relative criteria" do
+        Rating.new(:stars => 1).save
+        Rating.new(:stars => 5).save
+        Rating.all.sorted_by(:stars) { |q| q.endkey(3) }.size.should == 1
+      end
+
+      it "should be retrievable by combined criteria" do
+        User.new(:name => "paul", :age => 28).save
+        User.new(:name => "paul", :age => 72).save
+        User.new(:name => "atlas", :age => 99).save
+        User.all.sorted_by(:name, :age) { |q| q.startkey(["paul",0 ]).endkey(["paul", 50]) }.size.should == 1
+      end
+
+      it "should be retrievable by combined criteria where not all docs contain all attributes" do
+        User.new(:name => "paul", :age => 28).save
+        User.new(:name => "paul", :age => 72).save
+        User.new(:name => "atlas").save
+        User.all.sorted_by(:name, :age) { |q| q.startkey(["paul",0 ]).endkey(["paul", 50]) }.size.should == 1
+      end
+
+    end
+    
+  end  
+  
+  describe "defaults" do
+    
+    it "should be set on initialisation" do
+      r = Rating.new
+      r.stars.should == 5
+    end
+    
+    it "should be saved" do
+      r = Rating.new.save
+      RelaxDB.load(r._id).stars.should == 5
+    end
+
+    it "should be ignored once overwritten" do
+      r = Rating.new
+      r.stars = nil
+      r.save
+      RelaxDB.load(r._id).stars.should be_nil
+    end    
+    
+    it "may be a simple value" do
+      simple = Class.new(RelaxDB::Document) do 
+        property :foo, :default => :bar
+      end
+      simple.new.foo.should == :bar
+    end
+      
+    it "may be a proc" do
+      simple = Class.new(RelaxDB::Document) do 
+        property :foo, :default => lambda { :bar }
+      end
+      simple.new.foo.should == :bar      
+    end        
+        
+  end
+  
+  describe "validator" do
+    
+    it "should prevent an object from being saved if it evaluates to false" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { false }
+      end
+      r.new.save.should be_false
+    end
+
+    it "should pass the property value to the validator" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { |tu| tu >=0 && tu < 3 }
+      end
+      r.new(:thumbs_up => 2).save.should_not be_false
+      r.new(:thumbs_up => 3).save.should be_false
+    end
+
+    it "should add the validation error message if supplied, on failure" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { false }, :validation_msg => "Too many thumbs"
+      end
+      x = r.new
+      x.save
+      x.errors[:thumbs_up].should == "Too many thumbs"
+    end
+    
+    it "should perform all validations" do
+      r = Class.new(RelaxDB::Document) do
+        property :foo, :validator => lambda { false }, :validation_msg => "oof"
+        property :bar, :validator => lambda { false }, :validation_msg => "rab"
+      end
+      x = r.new
+      x.save
+      x.errors[:foo].should == "oof"
+      x.errors[:bar].should == "rab"
+    end
+    
+  end
+  
+end

data/spec/has_many_spec.rb

@@ -0,0 +1,139 @@
+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    
+        
+    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
+
+      it "should fail" do
+        # This may be implemented in future
+        lambda { User.new.items = [] }.should raise_error
+      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,121 @@
+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        
+           
+    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,46 @@
+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 == "_view/Zenith/mount"
+    end
+    
+    it "should contain URL and JSON encoded key when the key has been set" do
+      q = RelaxDB::Query.new("Zenith", "mount")
+      q.key("olympus")
+      q.view_path.should == "_view/Zenith/mount?key=%22olympus%22"
+    end
+    
+    it "should honour startkey, endkey and count" do
+      q = RelaxDB::Query.new("Zenith", "all_sorted_by_name_and_height")
+      q.startkey(["olympus"]).endkey(["vesuvius", 3600]).count(100)
+      q.view_path.should == "_view/Zenith/all_sorted_by_name_and_height?startkey=%5B%22olympus%22%5D&endkey=%5B%22vesuvius%22%2C3600%5D&count=100"
+    end
+        
+    it "should specify the key as the empty string if key was set to nil" do
+      q = RelaxDB::Query.new("", "")
+      q.key(nil)
+      q.view_path.should == "_view//?key=%22%22"
+    end
+    
+  end  
+      
+end