relaxdb 0.3.5

data/spec/callbacks_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# A little naiive, needs quite a bit more thought and work
+
+describe RelaxDB::Document, "callbacks" do
+  
+  before(:all) do
+    RelaxDB.configure :host => "localhost", :port => 5984, :design_doc => "spec_doc"
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec"
+  end
+  
+  describe "before_save" do
+  
+    it "should be run before the object is saved" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { |s| s.gem += 1 if s.unsaved? }
+        property :gem
+      end
+      p = c.new(:gem => 5).save
+      p.gem.should == 6
+    end
+    
+    it "should prevent the object from being saved if it returns false" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      c.new.save.should == false
+    end
+    
+    it "should add a description to errors when false is returned" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      x = c.new
+      x.save
+      x.errors[:before_save].should be
+    end    
+
+    it "should not prevent the object from being saved if it returns nil" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { nil }
+      end
+      c.new.save!
+    end
+    
+    it "may be a proc" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      c.new.save.should == false      
+    end
+    
+    it "may be a method" do
+      c = Class.new(RelaxDB::Document) do
+        before_save :never
+        def never; false; end
+      end
+      c.new.save.should == false
+    end
+    
+  end
+  
+  describe "after_save" do
+    
+    it "should be run after the object is saved" do
+      c = Class.new(RelaxDB::Document) do
+        after_save lambda { |s| s.gem +=1 unless s.unsaved? }
+        property :gem
+      end
+      p = c.new(:gem => 5).save
+      p.gem.should == 6
+    end
+    
+  end
+
+end

data/spec/derived_properties_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+class DpInvite < RelaxDB::Document
+  property :event_name, :derived => [:event, lambda { |en, i| i.event.name }]
+  belongs_to :event  
+end
+
+class DpEvent < RelaxDB::Document
+  property :name  
+end
+
+describe RelaxDB::Document, "derived properties" do
+  
+  before(:each) do
+    setup_test_db
+  end
+  
+  it "should have its value updated when the source is updated" do
+    e = DpEvent.new(:name => "shindig")
+    i = DpInvite.new(:event => e)
+    i.event_name.should == "shindig"
+  end
+  
+  it "should have its value persisted" do
+    e = DpEvent.new(:name => "shindig").save!
+    i = DpInvite.new(:event => e).save!
+    
+    RelaxDB.db.get_count = 0
+    i = RelaxDB.load i._id
+    i.event_name.should == "shindig"
+    RelaxDB.db.get_count.should == 1
+  end  
+    
+  it "should have its value updated when the source_id is updated for a saved event" do
+    e = DpEvent.new(:name => "shindig").save!
+    i = DpInvite.new(:event_id => e._id)
+    i.event_name.should == "shindig"
+  end  
+  
+  it "will not raise an exception when the source is nil" do
+    # See the rationale in Document.write_derived_props
+    DpInvite.new(:event => nil).save!
+  end  
+      
+  it "should only be updated for registered properties" do
+    invite = Class.new(RelaxDB::Document) do
+      property :event_name, :derived => [:foo, lambda { |en, i| i.event.name }]
+      belongs_to :event
+    end
+    
+    event = Class.new(RelaxDB::Document) do
+      property :name
+    end
+    
+    e = event.new(:name => "shindig")
+    i = invite.new(:event => e)
+    i.event_name.should be_nil
+  end
+  
+  it "should have the existing value passed to the first lambda param" do
+    invite = Class.new(RelaxDB::Document) do
+      property :event_name, :derived => [:event, lambda { |en, i| en.nil? ? i.event.name : "bar" }]
+      belongs_to :event
+    end
+    
+    event = Class.new(RelaxDB::Document) do
+      property :name
+    end
+    
+    e1 = event.new(:name => "shindig")
+    e2 = event.new(:name => "shindig2")
+    i = invite.new(:event => e1)
+    i.event = e2
+    i.event_name.should == "bar"
+  end
+  
+  it "should contintue to be derived post load" do
+    e = DpEvent.new(:name => "shindig").save!
+    i = DpInvite.new(:event => e).save!
+    
+    i = RelaxDB.load i._id
+    i.event_name.should == "shindig"
+    
+    e = DpEvent.new(:name => "gidnihs").save!
+    i.event = e
+    i.event_name.should == "gidnihs"
+  end    
+  
+  describe "multiple properties" do
+
+    it "should be derivable from the same source" do
+      invite = Class.new(RelaxDB::Document) do
+        property :name, :derived => [:event, lambda { |en, i| i.event.name }]
+        property :location, :derived => [:event, lambda { |en, i| i.event.location }]
+        belongs_to :event
+      end
+
+      event = Class.new(RelaxDB::Document) do
+        property :name
+        property :location
+      end
+
+      e = event.new(:name => "shindig", :location => "city17")
+      i = invite.new(:event => e)
+      i.name.should == "shindig"
+      i.location.should == "city17"
+    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, :design_doc => "spec_doc"
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec"
+  end
+
+  describe "#save" do
+    
+    it "should create a corresponding document in CouchDB" do
+      RelaxDB::DesignDocument.get("foo").save      
+      RelaxDB.load("_design/foo").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!
+      RelaxDB.load("_design/foo").should be_nil
+    end
+    
+  end
+
+end

data/spec/doc_inheritable_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe "Inheritance" do
+  
+  before(:each) do
+    setup_test_db
+  end
+  
+  describe "properties" do
+
+    it "should by inherited from a parent document" do
+      d = SubDescendant.new(:x => 1).save!
+      RelaxDB.reload(d).x.should == 1
+    end
+    
+    it "should store its own properties" do
+      r = RichDescendant.new(:x => 1, :foo => :bar).save!
+      RelaxDB.reload(r).x.should == 1
+      RelaxDB.reload(r).foo.should == "bar"
+    end
+    
+    it "validators should behave as normal" do
+      d = SubDescendant.new(:y => false)
+      d.save.should be_false
+      d.errors[:y].should == "Uh oh"
+    end
+    
+  end      
+    
+  describe "_all views" do
+    
+    it "should be rewritten" do
+      a = Ancestor.new(:x => 0).save!
+      d = Descendant.new(:x => 1).save!
+
+      Ancestor.all.should == [a, d]
+      Descendant.all.should == [d]
+    end
+
+    it "should function with inheritance trees" do
+      Inh::X.new.save!
+      
+      Inh::Y.new.save!
+      Inh::Y1.new.save!
+      
+      Inh::Z.new.save!
+      Inh::Z1.new.save!
+      Inh::Z2.new.save!
+      
+      Inh::X.all.size.should == 6
+      Inh::Y.all.size.should == 2
+      Inh::Y1.all.size.should == 1
+      Inh::Z.all.size.should == 3
+      Inh::Z1.all.size.should == 1
+      Inh::Z2.all.size.should == 1
+    end
+    
+  end
+  
+  describe "_by views" do
+    
+    it "should be rewritten for ancestors and generated for descendants" do
+      a = Ancestor.new(:x => 0).save!
+      d = Descendant.new(:x => 1).save!
+      
+      Ancestor.by_x.should == [a, d]
+      Descendant.by_x.should == [d]
+    end
+    
+  end
+  
+  describe "derived properties" do
+    
+    it "should be stored" do
+      u = User.new(:_id => "foo", :name => "u").save!
+      s = SubDescendant.new(:user => u).save!
+      r = RichDescendant.new(:user => u, :ukulele => u).save!
+      
+      RelaxDB.reload(s).user_name.should == "u"
+      RelaxDB.reload(r).user_name.should == "u"
+      RelaxDB.reload(r).ukulele_name.should == "u"
+    end
+    
+  end
+
+  describe "references" do
+    
+    it "should function as normal" do
+      u = User.new(:name => "u").save!
+      s = SubDescendant.new(:user => u).save!
+      r = RichDescendant.new(:user => u).save!
+      
+      RelaxDB.reload(s).user.name.should == "u"
+      RelaxDB.reload(r).user.name.should == "u"
+    end
+    
+  end
+    
+end

data/spec/document_spec.rb

@@ -0,0 +1,545 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::Document do
+  
+  before(:each) do
+    setup_test_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 Times" 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  
+    
+    it "should create a document with a non conflicing state" do
+      Atom.new.should_not be_update_conflict
+    end
+    
+  end
+  
+  describe "#initialize" do
+    
+    it "may be overridden by inheriting classes" do
+      i = Initiative.new(:x => "y").save
+      i = RelaxDB.load("y")
+      i.x.should == "y"
+      i.foo.should == :bar
+    end
+    
+  end
+        
+  describe "#to_json" do
+    
+    it "should not output nil attributes" do
+      Atom.new.to_json.should_not include("rev")
+    end
+    
+    it "should convert times to '%Y/%m/%d %H:%M:%S +0000' format" do
+      s = Time.at(0)
+      p = Primitives.new(:created_at => s).save
+      json = RelaxDB.get(p._id)
+      json["created_at"].should == "1970/01/01 00:00:00 +0000"
+    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 on first save only" do
+      ts = Time.now
+      p = Post.new
+      
+      created_at = p.save.created_at
+      created_at.should be_close(ts, 1)  
+      
+      roll_clock_forward(60) do
+        created_at = p.save.created_at
+        created_at.should be_close(ts, 1)  
+      end
+    end
+    
+    it "should set updated_at on each save" do
+      ts = Time.now
+      p = Primitives.new
+      
+      updated_at = p.save.updated_at
+      updated_at.should be_close(ts, 1)  
+      
+      roll_clock_forward(60) do
+        updated_at = p.save.updated_at
+        updated_at.should be_close(Time.at(ts.to_i + 60), 2)  
+      end      
+    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
+    
+    it "should set document conflict state on conflicting save" do
+      a1 = Atom.new
+      a2 = a1.dup
+      a1.save!
+      a2.save
+      a2.should be_update_conflict
+    end
+        
+  end
+  
+  describe "#save!" do
+    
+    it "should save objects" do
+      a = Atom.new.save
+      RelaxDB.load(a._id).should == a
+    end
+    
+    it "should raise ValidationFailure on validation failure" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { false }
+      end
+      lambda do
+        r.new.save!
+      end.should raise_error(RelaxDB::ValidationFailure)
+    end   
+    
+    it "should raise UpdateConflict on an update conflict" do
+      a1 = Atom.new
+      a2 = a1.dup
+      a1.save!
+      lambda { a2.save! }.should raise_error(RelaxDB::UpdateConflict)      
+    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 to modify state" do
+      o = BespokeWriter.new(:val => 101).save
+      o = RelaxDB.load o._id
+      o.val.should == 81
+    end
+    
+    it "may be used if effectively idempotent" do
+      o = BespokeWriter.new(:tt => "2009/04/01").save
+      RelaxDB.reload(o).tt.should == Time.parse("2009/04/01")
+      
+      o = BespokeWriter.new(:tt => Time.now).save
+      RelaxDB.reload(o).tt.should be_close(Time.now, 2)
+    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 be_false
+      p.false_bool.should_not be
+      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!
+      RelaxDB.load(p._id).should be_nil
+    end
+
+    it "should prevent the object from being resaved" do
+      p = Atom.new.save.destroy!
+      # Exepcted failure - see http://issues.apache.org/jira/browse/COUCHDB-292      
+      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 == []
+    end
+    
+  end
+  
+  describe ".all.size" do
+    
+    it "should return the total number of docs in a single query" do
+      docs = []
+      100.times { docs << Atom.new }
+      RelaxDB.bulk_save(*docs)
+      
+      RelaxDB.db.get_count = 0
+      Atom.all.size.should == 100
+      RelaxDB.db.get_count.should == 1
+    end
+    
+    it "should return 0 when no docs exist" do
+      Atom.all.size.should == 0
+    end
+    
+  end
+  
+  describe "by_" do
+      
+    it "should sort ascending by default" do
+      Post.new(:content => "b").save
+      Post.new(:content => "a").save
+      posts = Post.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.by_content :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.by_viewed_at
+      posts[0].content.should == "early"
+      posts[1].content.should == "late"
+    end
+    
+    it "should return the count when queried with reduce=true" do
+      docs = []
+      100.times { |i| docs << Primitives.new(:num => i) }
+      RelaxDB.bulk_save(*docs)
+      # Create the view
+      Primitives.by_num
+      count = RelaxDB.view "Primitives_by_num", :reduce => true
+      count.should == 100
+    end
+    
+    describe "results" do
+      
+      it "should be an empty array when no docs match" do
+        Post.by_subject.should == []
+      end
+
+      it "should be retrievable by exact criteria" do
+        Post.new(:subject => "foo").save
+        Post.new(:subject => "foo").save
+        Post.new(:subject => "bar").save
+        Post.by_subject(: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.by_stars(: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.by_name_and_age(: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.by_name_and_age(: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.by_num :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 }
+      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 pass the property value and object to the validator" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { |tu, o| tu >=0 && o.thumbs_up < 3 }
+      end
+      r.new(:thumbs_up => 2).save.should be
+      r.new(:thumbs_up => 3).save.should be_false
+    end
+    
+    it "should perform all validations" do
+      r = Class.new(RelaxDB::Document) do
+        property :foo, :validator => lambda { raise }, :validation_msg => "oof"
+        property :bar, :validator => lambda { raise }, :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 "should add a default error message if none is specified" do
+      r = Class.new(RelaxDB::Document) do
+        property :foo, :validator => lambda { raise }
+      end
+      x = r.new
+      x.save
+      x.errors[:foo].should_not be_blank
+    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(tu)
+          tu >=0 && tu < 3
+        end
+      end
+      r.new(:thumbs_up => 1).save.should be
+    end
+    
+    it "may be skipped by passing the property symbol to save" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { raise }
+      end
+      x = r.new
+      x.validation_skip_list << :thumbs_up
+      x.save!
+    end
+    
+  end
+  
+  describe "validation message" do
+  
+    it "should be set 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 "may be a proc accepting the prop only" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { false }, 
+          :validation_msg => lambda { |tu| "#{tu}" }
+      end      
+      x = r.new(:thumbs_up => 13)
+      x.save
+      x.errors[:thumbs_up].should == "13"
+    end
+    
+    
+    it "may be a proc accepting the prop and object" do
+      r = Class.new(RelaxDB::Document) do
+        property :thumbs_up, :validator => lambda { false }, 
+          :validation_msg => lambda { |tu, o| "#{tu} #{o.thumbs_up}" }
+      end      
+      x = r.new(:thumbs_up => 13)
+      x.save
+      x.errors[:thumbs_up].should == "13 13"
+    end
+    
+  end
+  
+  describe "predefined validator" do
+    
+    it "should be invoked when a symbol clash exists" do
+      c = Class.new(RelaxDB::Document) do
+        property :foo, :validator => :required
+        def required; raise; end;
+      end
+      c.new(:foo => :bar).save!.should be
+    end
+    
+    it "should prevent an object from being saved if validation fails" do
+      c = Class.new(RelaxDB::Document) do
+        property :foo, :validator => :required
+      end
+      c.new.save.should be_false
+    end    
+    
+  end
+  
+end