simply_stored 0.5.4 → 0.6.0

data/test/belongs_to_test.rb

@@ -1,173 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
-
-class BelongsToTest < 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 "raise an error if another property with the same name already exists" do
-        assert_raise(RuntimeError) do
-          class ::DoubleBelongsToUser
-            include SimplyStored::Couch
-            property :user
-            belongs_to :user
-          end
-        end
-      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/conflict_handling_test.rb

@@ -1,96 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
-
-class ConflictHandlingTest < 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/finder_test.rb

@@ -1,188 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
-
-class FinderTest < 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 'find the last as a reverse first' do
-        User.expects(:find).with(:first, :order => :desc)
-        User.last
-      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