simply_stored 0.3.6 → 0.3.7

data/CHANGELOG.md

@@ -1,6 +1,9 @@
 Changelog
 =============
 
+- Pre-populate the parent object on has_many and has_one associations so that user.posts.first.user
+  doesn't reload the user.
+
 - Add support for associations not named after the class [akm]
 
 0.3.3

data/lib/simply_stored/couch/has_many.rb

@@ -21,11 +21,12 @@ module SimplyStored
             descending = false
           end
 
-          cached_results = cached_results = send("_get_cached_#{name}")
+          cached_results = send("_get_cached_#{name}")
           cache_key = _cache_key_for(local_options)
           if forced_reload || cached_results[cache_key].nil? 
             cached_results[cache_key] = find_associated(options[:class_name], self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending, :foreign_key => options[:foreign_key])
             instance_variable_set("@#{name}", cached_results)
+            self.class.set_parent_has_many_association_object(self, cached_results[cache_key])
           end
           cached_results[cache_key]
         end
@@ -146,6 +147,14 @@ module SimplyStored
         end
       end
       
+      def set_parent_has_many_association_object(parent, child_collection)
+        child_collection.each do |child|
+          if child.respond_to?("#{parent.class.name.to_s.singularize.downcase}=")
+            child.send("#{parent.class.name.to_s.singularize.camelize.downcase}=", parent)
+          end
+        end
+      end
+      
       class Property
         attr_reader :name, :options
         

data/lib/simply_stored/couch/has_one.rb

@@ -43,12 +43,20 @@ module SimplyStored
           end
 
           if forced_reload || instance_variable_get("@#{name}").nil?
-            instance_variable_set("@#{name}", find_one_associated(options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key]))
+            found_object = find_one_associated(options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key])
+            instance_variable_set("@#{name}", found_object)
+            self.class.set_parent_has_one_association_object(self, found_object)
           end
           instance_variable_get("@#{name}")
         end
       end
       
+      def set_parent_has_one_association_object(parent, child)
+        if child.respond_to?("#{parent.class.name.to_s.singularize.downcase}=")
+          child.send("#{parent.class.name.to_s.singularize.camelize.downcase}=", parent)
+        end
+      end
+      
       class Property
         attr_reader :name, :options
       

data/lib/simply_stored/instance_methods.rb

@@ -7,7 +7,7 @@ module SimplyStored
     end
     
     def ==(other)
-      other._id == _id && other._rev == _rev
+      other.kind_of?(SimplyStored::Couch) && other._id == _id && other._rev == _rev
     end
 
     def eql?(other)

data/lib/simply_stored.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/simply_stored/storage')
 require File.expand_path(File.dirname(__FILE__) + '/simply_stored/class_methods_base')
 
 module SimplyStored
-  VERSION = '0.3.6'
+  VERSION = '0.3.7'
   class Error < RuntimeError; end
   class RecordNotFound < RuntimeError; end
 end

data/test/couchdb/couch_active_model_compatibility_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+begin
+  require 'active_model'
+
+  class CouchModel
+    include SimplyStored::Couch
+    property :name
+    validates_presence_of :name
+  end
+
+  class CouchActiveModelCompatibilityTest < Test::Unit::TestCase
+    def setup
+      @model = CouchModel.new
+    end
+    include ActiveModel::Lint::Tests
+  end
+
+rescue LoadError
+  puts "ActiveModel not installed, skipping lint tests."
+end
+
+

data/test/couchdb/couch_belongs_to_test.rb

@@ -0,0 +1,163 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../fixtures/couch')
+
+class CouchBelongsToTest < Test::Unit::TestCase
+  context "with associations" do
+    setup do
+      CouchPotato::Config.database_name = 'simply_stored_test'
+      recreate_db
+    end
+
+    context "with belongs_to" do
+      should "generate a view for the association" do
+        assert Post.respond_to?(:association_post_belongs_to_user)
+      end
+      
+      should "add the foreign key id to the referencing object" do
+        user = User.create(:title => "Mr.")
+        post = Post.create(:user => user)
+        
+        post = Post.find(post.id)
+        assert_equal user.id, post.user_id
+      end
+      
+      should "set also the foreign key id to nil if setting the referencing object to nil" do
+        user = User.create(:title => "Mr.")
+        post = Post.create(:user => user)
+        post.user = nil
+        post.save!
+        assert_nil post.reload.user
+        assert_nil post.reload.user_id
+      end
+      
+      should "fetch the object from the database when requested through the getter" do
+        user = User.create(:title => "Mr.")
+        post = Post.create(:user => user)
+        
+        post = Post.find(post.id)
+        assert_equal user, post.user
+      end
+      
+      should "mark the referencing object as dirty" do
+        user = User.create(:title => "Mr.")
+        post = Post.create
+        post.user = user
+        assert post.dirty?
+      end
+      
+      should "allow assigning a different object and store the id accordingly" do
+        user = User.create(:title => "Mr.")
+        user2 = User.create(:title => "Mrs.")
+        post = Post.create(:user => user)
+        post.user = user2
+        post.save
+        
+        post = Post.find(post.id)
+        assert_equal user2, post.user
+      end
+      
+      should "check the class and raise an error if not matching in belongs_to setter" do
+        post = Post.create
+        assert_raise(ArgumentError, 'expected Post got String') do
+          post.user = 'foo'
+        end
+      end
+      
+      should 'not query for the object twice in getter' do
+        user = User.create(:title => "Mr.")
+        post = Post.create(:user => user)
+        post = Post.find(post.id)
+        User.expects(:find).returns "user"
+        post.user
+        User.expects(:find).never
+        post.user
+      end
+      
+      should 'use cache in getter' do
+        post = Post.create
+        post.instance_variable_set("@user", 'foo')
+        assert_equal 'foo', post.user
+      end
+      
+      should "ignore the cache if force_reload is given as an option" do
+        user = User.create(:name => 'Dude', :title => 'Mr.')
+        post = Post.create(:user => user)
+        post.reload
+        post.instance_variable_set("@user", 'foo')
+        assert_not_equal 'foo', post.user(:force_reload => true)
+      end
+      
+      should 'set cache in setter' do
+        post = Post.create
+        user = User.create
+        assert_nil post.instance_variable_get("@user")
+        post.user = user
+        assert_equal user, post.instance_variable_get("@user")
+      end
+
+      should "not hit the database when the id column is empty" do
+        User.expects(:find).never
+        post = Post.create
+        post.user
+      end
+
+      should "know when the associated object changed" do
+        post = Post.create(:user => User.create(:title => "Mr."))
+        user2 = User.create(:title => "Mr.")
+        post.user = user2
+        assert post.user_changed?
+      end
+      
+      should "not be changed when an association has not changed" do
+        post = Post.create(:user => User.create(:title => "Mr."))
+        assert !post.user_changed?
+      end
+      
+      should "not be changed when assigned the same object" do
+        user = User.create(:title => "Mr.")
+        post = Post.create(:user => user)
+        post.user = user
+        assert !post.user_changed?
+      end
+      
+      should "not be changed after saving" do
+        user = User.create(:title => "Mr.")
+        post = Post.new
+        post.user = user
+        assert post.user_changed?
+        post.save!
+        assert !post.user_changed?
+      end
+      
+      should "handle a foreign_key of '' as nil" do
+        post = Post.create
+        post.user_id = ''
+        
+        assert_nothing_raised do
+          assert_nil post.user
+        end
+      end
+      
+      context "with aliased associations" do
+        should "allow different names for the same class" do
+          editor = User.create(:name => 'Editor', :title => 'Dr.')
+          author = User.create(:name => 'author', :title => 'Dr.')
+          assert_not_nil editor.id, editor.errors.inspect
+          assert_not_nil author.id, author.errors.inspect
+          
+          doc = Document.create(:editor => editor, :author => author)
+          doc.save!
+          assert_equal editor.id, doc.editor_id
+          assert_equal author.id, doc.author_id
+          doc = Document.find(doc.id)
+          assert_not_nil doc.editor, doc.inspect
+          assert_not_nil doc.author
+          assert_equal editor.id, doc.editor.id
+          assert_equal author.id, doc.author.id
+        end
+      end
+    end
+  end
+  
+
+end

data/test/couchdb/couch_conflict_handling_test.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../fixtures/couch')
+
+class CouchConflictHandlingTest < Test::Unit::TestCase
+  context "when handling conflicts" do
+    setup do
+      CouchPotato::Config.database_name = 'simply_stored_test'
+      recreate_db
+      @original = User.create(:name => 'Mickey Mouse', :title => "Dr.", :homepage => 'www.gmx.de')
+      @copy = User.find(@original.id)
+      User.auto_conflict_resolution_on_save = true
+    end
+    
+    should "be able to save without modifications" do
+      assert @copy.save
+    end
+    
+    should "be able to save when modification happen on different attributes" do
+      @original.name = "Pluto"
+      assert @original.save
+      
+      @copy.title = 'Prof.'
+      assert_nothing_raised do
+        assert @copy.save
+      end
+      
+      assert_equal "Pluto", @copy.reload.name
+      assert_equal "Prof.", @copy.reload.title
+      assert_equal "www.gmx.de", @copy.reload.homepage
+    end
+    
+    should "be able to save when modification happen on different, multiple attributes - remote" do
+      @original.name = "Pluto"
+      @original.homepage = 'www.google.com'
+      assert @original.save
+      
+      @copy.title = 'Prof.'
+      assert_nothing_raised do
+        assert @copy.save
+      end
+      
+      assert_equal "Pluto", @copy.reload.name
+      assert_equal "Prof.", @copy.reload.title
+      assert_equal "www.google.com", @copy.reload.homepage
+    end
+    
+    should "be able to save when modification happen on different, multiple attributes locally" do
+      @original.name = "Pluto"
+      assert @original.save
+      
+      @copy.title = 'Prof.'
+      @copy.homepage = 'www.google.com'
+      assert_nothing_raised do
+        assert @copy.save
+      end
+      
+      assert_equal "Pluto", @copy.reload.name
+      assert_equal "Prof.", @copy.reload.title
+      assert_equal "www.google.com", @copy.reload.homepage
+    end
+    
+    should "re-raise the conflict if there is no merge possible" do
+      @original.name = "Pluto"
+      assert @original.save
+      
+      @copy.name = 'Prof.'
+      assert_raise(RestClient::Conflict) do
+        assert @copy.save
+      end
+      
+      assert_equal "Prof.", @copy.name
+      assert_equal "Pluto", @copy.reload.name
+    end
+    
+    should "re-raise the conflict if retried several times" do
+      exception = RestClient::Conflict.new
+      CouchPotato.database.expects(:save_document).raises(exception).times(3)
+      
+      @copy.name = 'Prof.'
+      assert_raise(RestClient::Conflict) do
+        assert @copy.save
+      end
+    end
+    
+    should "not try to merge and re-save if auto_conflict_resolution_on_save is disabled" do
+      User.auto_conflict_resolution_on_save = false
+      exception = RestClient::Conflict.new
+      CouchPotato.database.expects(:save_document).raises(exception).times(1)
+      
+      @copy.name = 'Prof.'
+      assert_raise(RestClient::Conflict) do
+        assert @copy.save
+      end
+    end
+  end
+end

data/test/couchdb/couch_finder_test.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../fixtures/couch')
+
+class CouchFinderTest < Test::Unit::TestCase
+  context "when finding instances" do
+    setup do
+      CouchPotato::Config.database_name = 'simply_stored_test'
+      recreate_db
+    end
+ 
+    context "with find(:all)" do
+      setup do
+        User.create(:title => "Mr.")
+        User.create(:title => "Mrs.")
+      end
+      
+      should "return all instances" do  
+        assert_equal 2, User.find(:all).size
+      end
+      
+      should "allow a limit" do
+        assert_equal 1, User.find(:all, :limit => 1).size
+      end
+      
+      should "allow to order the results" do
+        assert_not_equal User.find(:all).map(&:id), User.find(:all, :order => :desc).map(&:id)
+        assert_equal User.find(:all).map(&:id).reverse, User.find(:all, :order => :desc).map(&:id)
+      end
+    end
+
+    context "to find all instances" do
+      should 'generate a default find_all view' do
+        assert User.respond_to?(:all_documents)
+      end
+      
+      should 'return all the users when calling all' do
+        User.create(:title => "Mr.")
+        User.create(:title => "Mrs.")
+        assert_equal 2, User.all.size
+      end
+    end
+    
+    context "to find one instance" do
+      should 'return one user when calling first' do
+        user = User.create(:title => "Mr.")
+        assert_equal user, User.first
+      end
+      
+      should 'understand the order' do
+        assert_nothing_raised do
+          User.first(:order => :desc)
+        end
+      end
+      
+      should 'return nil when no user found' do
+        assert_nil User.first
+      end
+    end
+    
+    context "when finding with just an identifier" do
+      should "find just one instance" do
+        user = User.create(:title => "Mr.")
+        assert User.find(user.id).kind_of?(User)
+      end
+      
+      should 'raise an error when no record was found' do
+        assert_raises(SimplyStored::RecordNotFound) do
+          User.find('abc')
+        end
+      end
+      
+      should 'tell you which class failed to load something' do
+        exception = nil
+        begin
+          User.find('abc')
+        rescue SimplyStored::RecordNotFound => e
+          exception = e
+        end
+        assert_equal "User could not be found with \"abc\"", exception.message
+      end
+      
+      should 'raise an error when nil was specified' do
+        assert_raises(SimplyStored::Error) do
+          User.find(nil)
+        end
+      end
+      
+      should 'raise an error when the record was not of the expected type' do
+        post = Post.create
+        assert_raises(SimplyStored::RecordNotFound) do
+          User.find(post.id)
+        end
+      end
+    end
+    
+    context "with a find_by prefix" do
+      setup do
+        recreate_db
+      end
+      
+      should "create a view for the called finder" do
+        User.find_by_name("joe")
+        assert User.respond_to?(:by_name)
+      end
+      
+      should 'not create the view when it already exists' do
+        User.expects(:view).never
+        User.find_by_name_and_created_at("joe", 'foo')
+      end
+      
+      should "create a method to prevent future loops through method_missing" do
+        assert !User.respond_to?(:find_by_title)
+        User.find_by_title("Mr.")
+        assert User.respond_to?(:find_by_title)
+      end
+      
+      should "call the generated view and return the result" do
+        user = User.create(:homepage => "http://www.peritor.com", :title => "Mr.")
+        assert_equal user, User.find_by_homepage("http://www.peritor.com")
+      end
+      
+      should 'find only one instance when using find_by' do
+        User.create(:title => "Mr.")
+        assert User.find_by_title("Mr.").is_a?(User)
+      end
+      
+      should "raise an error if the parameters don't match" do
+        assert_raise(ArgumentError) do
+          User.find_by_title()
+        end
+        
+        assert_raise(ArgumentError) do
+          User.find_by_title(1,2,3,4,5)
+        end
+      end
+    end
+    
+    context "with a find_all_by prefix" do
+      should "create a view for the called finder" do
+        User.find_all_by_name("joe")
+        assert User.respond_to?(:by_name)
+      end
+      
+      should 'not create the view when it already exists' do
+        User.expects(:view).never
+        User.find_all_by_name_and_created_at("joe", "foo")
+      end
+      
+      should "create a method to prevent future loops through method_missing" do
+        assert !User.respond_to?(:find_all_by_foo_attribute)
+        User.find_all_by_foo_attribute("Mr.")
+        assert User.respond_to?(:find_all_by_foo_attribute)
+      end
+      
+      should "call the generated view and return the result" do
+        user = User.create(:homepage => "http://www.peritor.com", :title => "Mr.")
+        assert_equal [user], User.find_all_by_homepage("http://www.peritor.com")
+      end
+      
+      should "return an emtpy array if none found" do
+        recreate_db
+        assert_equal [], User.find_all_by_title('Mr. Magoooo')
+      end
+      
+      should 'find all instances when using find_all_by' do
+        User.create(:title => "Mr.")
+        User.create(:title => "Mr.")
+        assert_equal 2, User.find_all_by_title("Mr.").size
+      end
+      
+      should "raise an error if the parameters don't match" do
+        assert_raise(ArgumentError) do
+          User.find_all_by_title()
+        end
+        
+        assert_raise(ArgumentError) do
+          User.find_all_by_title(1,2,3,4,5)
+        end
+      end
+    end      
+  end
+
+end