couchobject 0.5.0 → 0.6.0

data/spec/persistable/persistable_helper.rb

@@ -0,0 +1,194 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+HTTPResponse = Struct.new(:body)
+
+class Bike
+  include CouchObject::Persistable
+  
+  def initialize
+    @wheels = 2
+  end
+  attr_accessor :wheels
+  
+  def to_couch
+    {:wheels => @wheels}
+  end
+  
+  def self.from_couch(attributes)
+    bike = new
+    bike.wheels = attributes["wheels"]
+    bike
+  end
+end
+
+class MotorBike
+  include CouchObject::Persistable
+  def initialize
+    @wheels = 2
+  end
+  attr_accessor :wheels
+end
+
+class WithTimeStamp
+  include CouchObject::Persistable
+  add_timestamp_for :on_update, :on_create
+  
+  def intialize
+    @some_variable = "some value"
+    @other_variable = "other value"
+  end
+end
+
+class WithTimeStampCreatedOn
+  include CouchObject::Persistable
+  add_timestamp_for :on_create
+  
+  def intialize
+    @some_variable = "some value"
+    @other_variable = "other value"
+  end
+end
+
+class WithStorageLocation
+  include CouchObject::Persistable
+  database 'http://localhost:5984/mydb'
+end
+
+class SubSubobject
+  include CouchObject::Persistable
+  add_timestamp_for :on_create, :on_update
+  def initialize 
+    @value = "Initialized"
+  end
+  attr_accessor :value
+end
+
+class Subobject
+  include CouchObject::Persistable
+  add_timestamp_for :on_create, :on_update
+  def initialize
+    @some_other_class = SubSubobject.new
+  end
+  attr_accessor :some_other_class
+end
+
+class WithSubobject
+  include CouchObject::Persistable
+  database 'http://localhost:5984/mydb'
+  def initialize
+    @a_class = Subobject.new
+  end
+  attr_accessor :a_class
+end
+
+class ApartmentBuilding
+  include CouchObject::Persistable
+  database 'foo'
+  has_many :inhabitants
+  has_many :apartments
+end
+
+class Inhabitant
+  include CouchObject::Persistable
+  database 'foo2'
+  belongs_to :apartment_building, :as => :inhabitants
+end
+
+class Apartment
+  include CouchObject::Persistable
+  belongs_to :apartment_building, :as => :apartments
+end
+
+class House
+  include CouchObject::Persistable
+  database 'http://localhost:5984/mydb'
+  has_many :has
+end
+
+class WithCallbacks
+  include CouchObject::Persistable
+  database 'foo'
+  
+  def initialize
+    @calls = []
+  end
+  attr_accessor :calls
+
+  def before_save
+    @calls << "before_save"
+  end
+  def after_save
+    @calls << "after_save"
+  end
+  def before_create
+    @calls << "before_create"
+  end
+  def after_create
+    @calls << "after_create"
+  end
+  def before_update
+    @calls << "before_update"
+  end
+  def after_update
+    @calls << "after_update"
+  end
+  def before_delete
+    @calls << "before_delete"
+  end
+  def after_delete
+    @calls << "after_delete"
+  end
+end
+
+class Person
+  include CouchObject::Persistable
+  database 'foo'
+  has_one :life
+end
+
+class Life
+  include CouchObject::Persistable
+  database 'foo'
+  belongs_to :person, :as => :life
+end
+
+class Person
+  include CouchObject::Persistable
+  database 'http://localhost:5984/mydb'
+  has_one :life
+end
+
+class Life
+  include CouchObject::Persistable
+  database 'http://localhost:5984/mydb'
+  belongs_to :person, :as => :life
+end
+
+
+#
+# Classes used with the smart_save feature specs
+#
+class OtherMotorBike
+  include CouchObject::Persistable
+  smart_save
+  def initialize
+    @wheels = 2
+  end
+  attr_accessor :wheels
+end
+class OtherApartmentBuilding
+  include CouchObject::Persistable
+  smart_save
+  database 'foo'
+  has_many :inhabitants
+  has_many :apartments
+end
+class OtherInhabitant
+  include CouchObject::Persistable
+  database 'foo2'
+  smart_save
+  belongs_to :apartment_building, :as => :inhabitants
+  def change
+    @changable_value = false
+  end
+end

data/spec/persistable/relations.rb

@@ -0,0 +1,470 @@
+require File.dirname(__FILE__) + '/persistable_helper.rb'
+
+describe CouchObject::Persistable, "methods added and their values: " do
+  before(:each) do
+    @building = ApartmentBuilding.new
+    @inhabitant = Inhabitant.new
+    @apartment = Apartment.new
+    
+    @building.stub!(:couch_load_has_many_relations).
+      and_return(CouchObject::Persistable::HasManyRelation.new(@building))
+    @inhabitant.stub!(:couch_load_has_many_relations).
+      and_return(CouchObject::Persistable::HasManyRelation.new(@inhabitant))
+    @apartment.stub!(:couch_load_has_many_relations).
+      and_return(CouchObject::Persistable::HasManyRelation.new(@apartment))
+  end
+  
+  it "should give ApartmentBuilding inhabitant getters and setters" do
+    @building.respond_to?(:inhabitants).should == true
+    @building.respond_to?(:apartments).should == true
+  end
+  
+  it "should give Inhabitant apartment_building getters and setters" do
+    @inhabitant.respond_to?(:apartment_building).should == true
+    @inhabitant.respond_to?(:apartment_building=).should == true
+  end
+  
+  it "should give Apartment apartment_building getters and setters" do
+    @apartment.respond_to?(:apartment_building).should == true
+    @apartment.respond_to?(:apartment_building=).should == true
+  end
+  
+  it "should be able to list the classes it has relations to" do
+    @building.respond_to?(:has_many).should == true
+    @building.respond_to?(:belongs_to).should == true
+    @apartment.respond_to?(:has_many).should == true
+    @apartment.respond_to?(:belongs_to).should == true
+    @inhabitant.respond_to?(:has_many).should == true
+    @inhabitant.respond_to?(:belongs_to).should == true
+  end
+
+  it "should be able to list as what it has belongs_to relations" do
+    @apartment.belongs_to.each do |what_it_belongs_to|
+      @apartment.respond_to?("belongs_to_#{what_it_belongs_to}_as".to_sym).
+        should == true
+      @apartment.send("belongs_to_#{what_it_belongs_to}_as".to_sym).
+          should == :apartments  
+    end
+    @inhabitant.belongs_to.each do |what_it_belongs_to|
+      @inhabitant.respond_to?("belongs_to_#{what_it_belongs_to}_as".to_sym).
+        should == true
+      @inhabitant.send("belongs_to_#{what_it_belongs_to}_as".to_sym).
+          should == :inhabitants  
+    end
+  end
+  
+  it "should list the has_many relations as an array" do
+    @building.has_many.should be_a_kind_of(Array)
+    @apartment.has_many.should be_a_kind_of(Array)
+    @inhabitant.has_many.should be_a_kind_of(Array)
+  end
+  
+  it "should list the belongs_to relation as a symbol or nil" do
+    @inhabitant.belongs_to.should be_a_kind_of(Array)
+    @apartment.belongs_to.should be_a_kind_of(Array)
+    @building.belongs_to.should == []
+  end
+  
+  it "should be able to return the names of the accessor methods used to access its relations" do
+    
+    @building.has_many.should == [:inhabitants, :apartments]
+    @inhabitant.belongs_to.should == [:apartment_building]
+    @apartment.belongs_to.should == [:apartment_building]
+  end
+    
+end
+
+describe CouchObject::Persistable, "getting and setting relations: " do
+  before(:each) do
+    @building_1 = ApartmentBuilding.new
+    @building_2 = ApartmentBuilding.new
+    @inhabitant_1 = Inhabitant.new
+    @inhabitant_2 = Inhabitant.new
+    @apartment = Apartment.new
+    
+    @db = mock("mock db")
+    # Should call the DB at all...
+    CouchObject::Database.should_receive(:open).exactly(0).and_return(@db)
+   
+    @building_1.stub!(:couch_load_has_many_relations).and_return(CouchObject::Persistable::HasManyRelation.new(@building_1))
+    @building_2.stub!(:couch_load_has_many_relations).and_return(CouchObject::Persistable::HasManyRelation.new(@building_2))
+    @inhabitant_1.stub!(:couch_load_has_many_relations).and_return(CouchObject::Persistable::HasManyRelation.new(@inhabitant_1))
+    @inhabitant_2.stub!(:couch_load_has_many_relations).and_return(CouchObject::Persistable::HasManyRelation.new(@inhabitant_2))
+    @apartment.stub!(:couch_load_has_many_relations).and_return(CouchObject::Persistable::HasManyRelation.new(@apartment))
+  end
+  
+  it "should return an empty array for empty has_many relatoins" do
+    @building_1.inhabitants.should be_a_kind_of(Array)
+    @building_1.inhabitants.should == []
+  end
+  
+  it "should return nil for empty belongs_to relatoins" do
+    @inhabitant_1.apartment_building.should == nil
+  end
+  
+  it "should be able to add any number of object to a has_many relation and get them again" do
+    @building_1.inhabitants.should == []
+    @building_1.inhabitants << @inhabitant_1 << @inhabitant_2
+    # @building_1.inhabitants.size.should == 2
+    # @building_1.inhabitants.should == [@inhabitant_1, @inhabitant_2]
+  end
+  
+  it "should be able to assign a class that it belongs to and retrieve it" do
+    @inhabitant_1.apartment_building = @building_1
+    @inhabitant_1.apartment_building.should == @building_1
+    @inhabitant_1.apartment_building = @building_2
+    @inhabitant_1.apartment_building.should_not == @building_1
+  end
+  
+  it "when setting a has_many relationsship, the related class should be updated so it has a belongs_to relationsship with the other class" do
+    @building_1.inhabitants << @inhabitant_1
+    @inhabitant_1.apartment_building.should == @building_1
+  end
+  
+  it "should be able to remove an object from a has_many relationsship" do
+    @building_1.inhabitants << @inhabitant_1
+    @building_1.inhabitants.size.should == 1
+    @building_1.inhabitants.remove(@inhabitant_1)
+    @building_1.inhabitants.size.should == 0
+    @inhabitant_1.apartment_building.should == nil
+  end
+  
+  it "when setting a belongs_to relationsship, the related class should be updated so it has a has_many relationsship to the other class" do
+    @inhabitant_1.apartment_building = @building_1
+    @building_1.inhabitants.size.should == 1
+    @building_1.inhabitants.first.should == @inhabitant_1
+  end
+  
+  it "should be able to set a belongs_to relationship to a master that already has children" do
+    @building_1.inhabitants << @inhabitant_1
+    @building_1.inhabitants.size.should == 1
+    @inhabitant_2.apartment_building = @building_1
+    @building_1.inhabitants.size.should == 2
+  end
+
+end
+
+describe CouchObject::Persistable, "errors when creating classes with bad relations :)" do
+  it "should raise an error for badly formatted belongs_to relations" do
+    lambda {
+      class Garage
+        include CouchObject::Persistable
+        belongs_to :apartment_building # missing , :as => :something
+      end      
+    }.should raise_error(CouchObject::Errors::BelongsToAssociationError)
+
+    lambda {
+      class Lamp
+        include CouchObject::Persistable
+        belongs_to # missing :apartment_building, :as => :something
+      end      
+    }.should raise_error(CouchObject::Errors::BelongsToAssociationError)
+
+    lambda {
+      class Mouse
+        include CouchObject::Persistable
+        belongs_to :apartment_building, :as => :animal # is correct
+      end      
+    }.should_not \
+      raise_error(CouchObject::Errors::BelongsToAssociationError)
+    
+    
+  end
+  
+  it "should raise an error for badly formatted has_many relations" do
+    lambda {
+      class Oven
+        include CouchObject::Persistable
+        has_many # missing what it is related to :users
+      end      
+    }.should raise_error(CouchObject::Errors::HasManyAssociationError)
+
+    lambda {
+      class FavoriteOven
+        include CouchObject::Persistable
+        has_many :users
+      end      
+    }.should_not \
+      raise_error(CouchObject::Errors::HasManyAssociationError)
+
+  end
+
+end
+
+describe CouchObject::Persistable, "saving related objects: " do
+  before(:each) do
+    @building = ApartmentBuilding.new
+    @apartment = Apartment.new
+    
+    @db = mock("mock db")
+    
+    content = HTTPResponse.new(JSON.unparse({
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+    }))
+        
+    @document_response = CouchObject::Response.new(content)
+  end
+  
+  it "a class should save it's has_many relations" do 
+    CouchObject::Database.should_receive(:open).exactly(3).and_return(@db)
+    @db.should_receive(:post).exactly(3).and_return(@document_response)
+        
+    another_apartment = @apartment.clone
+    
+    @apartment.new?.should == true
+    another_apartment.new?.should == true
+    @building.new?.should == true
+    
+    # Should not load the relations because it is a new object
+    @building.apartments.class.should == \
+      CouchObject::Persistable::HasManyRelation
+    
+    @building.apartments << @apartment << another_apartment
+    @building.apartments.size.should == 2
+    
+    @building.inhabitants.class.should == \
+      CouchObject::Persistable::HasManyRelation
+      
+    @building.inhabitants.size.should == 0
+        
+    @apartment.new?.should == true
+    another_apartment.new?.should == true
+    @building.new?.should == true    
+    
+    # Should call save on itself which results in a post, and
+    # then on its children which also results in a post.
+    # And also load it's inhabitants relations
+    @building.save
+    
+    @apartment.new?.should == false 
+    another_apartment.new?.should == false    
+    
+  end
+  
+  it "should save its belongs_to relation if it is unsaved" do
+    CouchObject::Database.should_receive(:open).exactly(2).and_return(@db)
+    @db.should_receive(:post).exactly(2).and_return(@document_response)
+
+    @building.new?.should == true
+    @apartment.new?.should == true    
+    @building.apartments << @apartment
+    
+    @apartment.save("foo")
+    
+    @apartment.new?.should == false
+    @building.new?.should == false
+    
+    @building.id.should_not == nil
+    @apartment.id.should_not == nil
+        
+  end
+  
+  it "a class that normally is in a belongs_to relation but doesn't have a relation set should be able to save" do
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    @db.should_receive(:post).exactly(1).and_return(@document_response)
+  
+    @apartment.new?.should == true
+    @apartment.save("foo")
+    @apartment.new?.should == false      
+  end
+
+  it "should not load the belongs_to relations if they are not already loaded before saving" do
+    @inhabitant_content = %{ {"_id":"50F1A07A283C1879057AFE4C4B727D35","_rev":"1957693345","belongs_to":{"inhabitants":"12A64B5156002BFD66F23F559C5AD5FA"},"class":"Inhabitant","attributes":{}}
+    }
+    
+    response = HTTPResponse.new(@inhabitant_content)
+    
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    
+    @db.should_receive(:get).once.with("foo").and_return(response)
+              
+    inhabitant = Inhabitant.get_with_smart_save("foo")
+    inhabitant.location.should_not == nil
+    
+    # Telling the object not to load its relatives
+    inhabitant.save
+    
+  end
+end
+
+describe CouchObject::Persistable, "loading object relations: " do
+  before(:each) do
+    @db = mock("mock db")
+
+    @view_content_no_rows = %{
+      {"total_rows":3,"rows":[]}
+    }
+
+    @apartment_building_content = %{ {"_id":"A26EDC59D99D50C2CB2615404D357E49","_rev":"1756574922","class":"ApartmentBuilding","attributes":{}}
+    }
+    
+    @inhabitant_content = %{ {"_id":"50F1A07A283C1879057AFE4C4B727D35","_rev":"1957693345","belongs_to":{"inhabitants":"12A64B5156002BFD66F23F559C5AD5FA"},"class":"Inhabitant","attributes":{}}
+    }
+    
+    @inhabitant_content_from_view = %{
+      {"total_rows":2,"offset":0,"rows":[{"id":"50F1A07A283C1879057AFE4C4B727D35","key":["12A64B5156002BFD66F23F559C5AD5FA","inhabitants"],"value":{"_id":"50F1A07A283C1879057AFE4C4B727D35","_rev":"1957693345","class":"Inhabitant","attributes":{},"belongs_to":{"inhabitants":"12A64B5156002BFD66F23F559C5AD5FA"}}}]}
+    }
+          
+  @apartment_building_inhabitants = %{
+ {"total_rows":2,"offset":0,"rows":[{"id":"241757E4D7D2272C78048B4007399837","key":["12A64B5156002BFD66F23F559C5AD5FA","inhabitants"],"value":{"_id":"241757E4D7D2272C78048B4007399837","_rev":"2508041460","class":"Inhabitant","attributes":{},"belongs_to":{"inhabitants":"CCC19E6CAE557D058CC8E0961507AC4C"}}},{"id":"E94C93DEDB94BFC30B9AB396D4874D52","key":["12A64B5156002BFD66F23F559C5AD5FA","inhabitants"],"value":{"_id":"E94C93DEDB94BFC30B9AB396D4874D52","_rev":"960098874","class":"Inhabitant","attributes":{},"belongs_to":{"inhabitants":"CCC19E6CAE557D058CC8E0961507AC4C"}}}]}
+  }
+    
+  end
+  
+  it "should load all has_many relations when needed" do
+    response = HTTPResponse.new(@apartment_building_content)
+    response_relation = HTTPResponse.new(@apartment_building_inhabitants)
+    
+    CouchObject::Database.should_receive(:open).exactly(2).and_return(@db)
+    
+    @db.should_receive(:get).with("foo").and_return(response)
+      
+    # has_many relations are loaded
+    @db.should_receive(:get).
+      with("_view/couch_object_has_many_relations/related_documents?" + \
+      "key=[%22A26EDC59D99D50C2CB2615404D357E49%22,%22inhabitants%22]").
+      and_return(response_relation)
+        
+    apartment_building = ApartmentBuilding.get_by_id("foo")
+    apartment_building.location.should_not == nil
+        
+    # The content should be loaded on first request!
+    apartment_building.inhabitants.size.should == 2
+    
+  end
+  
+  it "should load belongs_to relations when needed" do
+    response_inhabitant = HTTPResponse.new(@inhabitant_content)
+    response_inhabitant_from_view = HTTPResponse.
+      new(@inhabitant_content_from_view)
+    response_apartment_buil = HTTPResponse.new(@apartment_building_content)
+    
+    # 1. class gets loaded
+    # 2. belongs_to relation is loaded
+    # 3. then self is added to the belongs_to relations has_many relation
+    #     which is first loaded from the DB
+    # 4. ? I don't know where it gets called...
+    CouchObject::Database.should_receive(:open).exactly(4).and_return(@db)
+    
+    @db.should_receive(:get).with("foo").once.and_return(response_inhabitant)
+    @db.should_receive(:get).once.
+      with("12A64B5156002BFD66F23F559C5AD5FA").
+      and_return(response_apartment_buil) 
+    @db.should_receive(:get).once.with("_view/couch_object_has_many_relat" + \
+      "ions/related_documents?key=[%22A26EDC59D99D50C2CB2615404D357E49" + \
+      "%22,%22inhabitants%22]").and_return(response_inhabitant_from_view)
+    
+    # 1)
+    inhabitant = Inhabitant.get_by_id("foo","foo_db")
+    inhabitant.new?.should == false
+    
+    # 2)
+    # 3)
+    inhabitant.apartment_building.class.should == ApartmentBuilding
+    inhabitant.apartment_building.new?.should == false        
+    inhabitant.apartment_building.inhabitants.first.should == inhabitant
+    
+  end
+
+  it "should be possible to tell the object not to load its has many relations" do
+    response = HTTPResponse.new(@apartment_building_content)
+    
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    
+    @db.should_receive(:get).with("foo").and_return(response)
+              
+    apartment_building = ApartmentBuilding.get_by_id("foo")
+    apartment_building.location.should_not == nil
+        
+    # Telling the object not to load its relatives
+    apartment_building.do_not_load_has_many_relations
+        
+    # The content should be loaded on first request!
+    apartment_building.inhabitants.size.should == 0
+    
+  end
+
+  it "should be possible to tell the object not to load its has many relations" do
+    response = HTTPResponse.new(@inhabitant_content)
+    
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    
+    @db.should_receive(:get).once.with("foo").and_return(response)
+              
+    inhabitant = Inhabitant.get("foo")
+    inhabitant.location.should_not == nil
+    
+    # Telling the object not to load its relatives
+    inhabitant.do_not_load_belongs_to_relations
+        
+    # The content should be loaded on first request!
+    inhabitant.apartment_building.should == nil
+    
+  end
+
+end
+
+describe CouchObject::Persistable, "has_one relations" do
+  before(:each) do
+    @person = Person.new
+    @life = Life.new
+    
+    @db = mock("mock db")
+    
+    content = HTTPResponse.new(JSON.unparse({
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+    }))
+        
+    @document_response = CouchObject::Response.new(content)
+  end
+  
+  it "should be able to set a has_one relation" do
+    @person.life = @life
+    @life.person.should == @person
+
+    @person.life = nil
+    @life.person.should == nil
+    
+    @life.person = @person
+    @person.life.should == @life
+  end
+  
+  it "should be able to save its has_one relation" do
+    CouchObject::Database.should_receive(:open).exactly(2).and_return(@db)
+    @db.should_receive(:post).exactly(2).and_return(@document_response)
+    @person.life = @life
+    @person.save
+    @person.new?.should == false
+    @life.new?.should == false
+  end
+  
+  it "the child should save it's has_one parent when it is a new object" do
+    CouchObject::Database.should_receive(:open).exactly(2).and_return(@db)
+    @db.should_receive(:post).exactly(2).and_return(@document_response)
+    @person.life = @life
+    @life.save
+    @person.new?.should == false
+    @life.new?.should == false
+  end
+
+  it "should only save the child when the parent isn't new" do
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    @db.should_receive(:post).exactly(1).and_return(@document_response)
+    @person.life = @life
+    # fake the parent into being an old object
+    @person.new?.should == true
+    @person.instance_variable_set("@id", 123)
+    @person.instance_variable_set("@revision", 123)    
+    @person.new?.should == false
+
+    @life.save
+
+    @life.new?.should == false
+  end
+  
+  
+
+
+end