cohitre-relaxdb 0.2.2

data/spec/denormalisation_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Experimental only for now
+
+class Tree < RelaxDB::Document
+  property :name
+  property :climate
+  has_one :leaf
+end
+
+class Leaf < RelaxDB::Document
+  belongs_to :tree, :denormalise => [:name]
+end
+
+describe RelaxDB::Document, "denormalisation" 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 "belongs_to" do
+        
+    it "should store denormalised options in its json representation" do
+      tree = Tree.new(:name => "sapling").save
+      leaf = Leaf.new(:tree => tree)
+      obj = JSON.parse(leaf.to_json)
+      obj["tree_name"].should == "sapling"
+    end
+
+    it "should ignore denormalised options for nil properties" do
+      Leaf.new.to_json
+    end
+    
+    it "should not interfere with normal belongs_to behaviour" do
+      tree = Tree.new(:name => "sapling", :climate => "tropical").save
+      leaf = Leaf.new(:tree => tree).save
+      leaf = RelaxDB.load(leaf._id)
+      leaf.tree.name.should == "sapling"
+      leaf.tree.climate.should == "tropical"
+    end
+    
+  end
+  
+end

data/spec/design_doc_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::DesignDocument 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 "#save" do
+    
+    it "should create a corresponding document in CouchDB" do
+      RelaxDB::DesignDocument.get("foo").save      
+      RelaxDB.load("_design%2Ffoo").should_not be_nil
+    end
+    
+  end
+
+  describe "#destroy" do
+    
+    it "should delete the corresponding document from CouchDB" do
+      dd = RelaxDB::DesignDocument.get("foo").save
+      dd.destroy!
+      lambda { RelaxDB.load("_design%2Ffoo") }.should raise_error
+    end
+    
+  end
+
+end

data/spec/document_spec.rb

@@ -0,0 +1,364 @@
+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
+      Atom.new._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 "user defined property reader" do
+    
+    it "should not effect normal operation" do
+      o = BespokeReader.new(:val => 101).save
+      o = RelaxDB.load o._id
+      o.val.should == 106
+    end
+    
+    it "should not modify internal state" do
+      o = BespokeReader.new(:val => 101).save
+      o = RelaxDB.load o._id
+      o.instance_variable_get(:@val).should == 101
+    end
+            
+  end
+
+  describe "user defined property writer" do
+    
+    it "should not be used" do
+      o = BespokeWriter.new(:val => 101).save
+      o = RelaxDB.load o._id
+      o.val.should == 81
+    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
+      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
+      
+      it "should be retrievable by a multi key post" do
+        5.times { |i| Primitives.new(:num => i).save }
+        ps = Primitives.all.sorted_by(:num) { |q| q.keys([0, 4]) }
+        ps.map { |p| p.num }.should == [0, 4]
+      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 prevent an object from being saved if it throws an exception" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { raise "foo" }
+      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 be
+      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
+    
+    it "should prevent saving unless all validations pass" do
+      r = Class.new(RelaxDB::Document) do
+        property :foo, :validator => lambda { false }
+        property :bar, :validator => lambda { true }
+      end
+      x = r.new
+      x.save.should == false
+    end
+    
+    it "may be a proc" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { false }
+      end
+      r.new.save.should be_false      
+    end
+    
+    it "may be a method" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => :count_em
+        def count_em
+          false
+        end
+      end
+      r.new.save.should be_false
+    end
+    
+  end
+  
+end

data/spec/has_many_spec.rb

@@ -0,0 +1,147 @@
+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
+
+      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