save_queue 0.3.0 → 0.4.0

data/spec/object_queue_spec.rb

@@ -5,35 +5,25 @@ describe SaveQueue::ObjectQueue do
   let(:queue)   { SaveQueue::ObjectQueue.new }
   let(:element) { new_element(:element)       }
 
-  [:add, :<<, :push].each do |method|
+  ADD_METHODS.each do |method|
     describe "##{method}" do
       #it "should add only objects that implement SaveQueue::Object interface" do
-      it "should accept objects that respond to #save and #has_unsaved_changes?" do
-        element = stub(:element, :save => true, :has_unsaved_changes? => true)
+      it "should accept objects that respond to #save" do
+        element = stub(:element, :save => true)
         expect{ queue.send method, element }.not_to raise_error
       end
 
       it "should not accept objects that does not respond to #save" do
-        element.unstub(:save)
+        element = stub(:element)
         expect{ queue.send method, element }.to raise_error ArgumentError, "#{element.inspect} does not respond to #save"
       end
-
-      it "should not accept objects that does not respond to #has_unsaved_changes?" do
-        element.unstub(:has_unsaved_changes?)
-        expect{ queue.send method, element }.to raise_error ArgumentError, "#{element.inspect} does not respond to #has_unsaved_changes?"
-      end
     end
   end
 
-  it "#<< method should be able to add objects in chain" do
-    queue << new_element << new_element
-    queue.should have(2).elements
-  end
-
   describe "#save" do
-    it "should save all object in queue" do
+    it "should save all objects in queue" do
       5.times do
-        element = stub(:element, :has_unsaved_changes? => true)
+        element = stub
         element.should_receive(:save).once
         queue << element
       end
@@ -41,66 +31,67 @@ describe SaveQueue::ObjectQueue do
       queue.save
     end
 
-    it "should save an object if it has unsaved changes" do
-      element = stub(:element)
-      element.stub(:has_unsaved_changes?).and_return(true)
-      element.should_receive(:save).once
-
-      queue << element
-      queue.save
+    it "should clear itself if saved successfully" do
+      #queue.should_receive(:clear).once
+      queue.save.should be_true
+      queue.should be_empty
     end
 
-    it "should not save an object if it has not been changed" do
-      element = stub(:element)
-      element.stub(:has_unsaved_changes?).and_return(false)
-      element.should_not_receive(:save)
-
+    it "should fail if element#save returns boolean false" do
+      element = new_element
+      element.stub(:save).and_return(false)
       queue << element
-      queue.save
+      queue.save.should be_false
     end
 
-    it "should save an object if it has changed state after been added to a queue" do
-      element = new_element(:element, :changed => false, :saved => true)
-
-      queue << element
-      
-      element.stub(:has_unsaved_changes?).and_return(true)
+    it "should not fail if element#save returns other than boolean false" do
+      ["", 0, nil, "string", true, Class.new].each do |value|
+        element = new_element
+        element.stub(:save).and_return(value)
+        queue << element
+      end
 
-      element.should_receive(:save).once.and_return(true)
-      queue.save
+      queue.save.should be_true
     end
   end
 
   context "at least one object in queue was not saved" do
     before(:each) do
       @objects ={}
-      queue << @objects[:valid1]               = new_element(:valid1)
-      queue << @objects[:valid2]               = new_element(:valid2)
-      queue << @objects[:not_changed]          = new_element(:not_changed,         :changed => false, :saved => true)
-      queue << @objects[:unsaved_but_changed]  = new_element(:unsaved_but_changed, :changed => true,  :saved => false)
-      queue << @objects[:saved]                = new_element(:saved,               :changed => true,  :saved => true)
-      queue << @objects[:valid3]               = new_element(:valid3)
+      queue << @objects[:valid1]   = new_element(:valid1)
+      queue << @objects[:valid2]   = new_element(:valid2)
+      queue << @objects[:unsaved]  = new_element(:unsaved,  :saved => false)
+      queue << @objects[:saved]    = new_element(:saved,    :saved => true)
+      queue << @objects[:valid3]   = new_element(:valid3)
     end
 
     describe "#save!" do
       it "should set errors" do
-        expect {queue.save!}.to raise_error
+        queue.save! rescue nil
 
         queue.errors[:save].should_not be_empty
-        queue.errors.should eq :save => { :processed  => @objects.values_at(:valid1, :valid2, :not_changed),
-                                          :saved      => @objects.values_at(:valid1, :valid2),
-                                          :failed     => @objects[:unsaved_but_changed],
-                                          :pending    => @objects.values_at(:not_changed, :saved, :valid3) }
+        queue.errors.should eq :save => { :saved      => @objects.values_at(:valid1, :valid2),
+                                          :failed     => @objects[:unsaved],
+                                          :pending    => @objects.values_at(:saved, :valid3) }
       end
       
       it "should raise SaveQueue::FailedSaveError" do
         expect{  queue.save! }.to raise_error(SaveQueue::FailedSaveError) {|error| \
-          error.context.should == { :processed  => @objects.values_at(:valid1, :valid2, :not_changed),
-                                    :saved      => @objects.values_at(:valid1, :valid2),
-                                    :failed     => @objects[:unsaved_but_changed],
-                                    :pending    => @objects.values_at(:not_changed, :saved, :valid3) }
+          error.context.should == { :saved      => @objects.values_at(:valid1, :valid2),
+                                    :failed     => @objects[:unsaved],
+                                    :pending    => @objects.values_at(:saved, :valid3) }
         }
       end
+
+      # TODO remove duplication
+      it "should not clear queue" do
+        queue.should_not_receive(:clear)
+        queue.save! rescue nil
+      end
+
+      it "should not remove/add elements from/to queue" do
+        expect { queue.save! rescue nil }.to_not change { queue.size }.to raise_error
+      end
     end
 
     describe "#save" do
@@ -112,40 +103,39 @@ describe SaveQueue::ObjectQueue do
         queue.save
 
         queue.errors[:save].should_not be_empty
-        queue.errors.should eq :save => { :processed  => @objects.values_at(:valid1, :valid2, :not_changed),
-                                          :saved      => @objects.values_at(:valid1, :valid2),
-                                          :failed     => @objects[:unsaved_but_changed],
-                                          :pending    => @objects.values_at(:not_changed, :saved, :valid3) }
+        queue.errors.should eq :save => { :saved      => @objects.values_at(:valid1, :valid2),
+                                          :failed     => @objects[:unsaved],
+                                          :pending    => @objects.values_at(:saved, :valid3) }
       end
       
       it "should not raise SaveQueue::FailedSaveError" do
         expect{  queue.save }.not_to raise_error(SaveQueue::FailedSaveError)
       end
+
+      it "should not clear queue" do
+        queue.should_not_receive(:clear)
+        queue.save
+      end
+
+      it "should not remove/add elements from/to queue" do
+        expect { queue.save }.to_not change { queue.size }
+      end
     end
 
     context "after fixing all failed objects" do
       before(:each) do
         queue.save.should be_false
-        @objects[:unsaved_but_changed].stub(:save).and_return(true)
+        @objects[:unsaved].stub(:save).and_return(true)
       end
 
-      it "should save all pending objects" do
-        @objects.values_at(:saved, :valid3).each do |object|
+      it "should save all objects" do
+        @objects.each_value do |object|
           object.should_receive(:save).once
         end
 
         queue.save.should be_true
       end
 
-      it "should not save already saved objects" do
-        pending "rewrite this test as integration"
-        @objects.values_at(:valid1, :valid2, :not_changed).each do |object|
-          object.should_not_receive(:save)
-        end
-
-        queue.save.should be_true
-      end
-
       it "should not have any errors" do
         queue.save
         queue.errors.should be_empty

data/spec/object_spec.rb

@@ -4,205 +4,166 @@ require "save_queue/object"
 describe SaveQueue::Object do
   let(:object) { new_object }
 
-  describe "#has_unsaved_changes?" do
-    it "should return true for changed object" do
-      object.mark_as_changed
-      object.should have_unsaved_changes
-    end
-
-    it "should return false for unchanged object" do
-      object.mark_as_saved
-      object.should_not have_unsaved_changes
-    end
-
-    it "should return false for new object" do
-      klass = Class.new
-      klass.send :include, SaveQueue::Object
-
-      klass.new.should_not have_unsaved_changes
-    end
-  end
-
-  describe "marks" do
-    it "should change state of an object" do
-      object.mark_as_saved
-      object.should_not have_unsaved_changes
-      object.mark_as_changed
-      object.should have_unsaved_changes
-      object.mark_as_saved
-      object.should_not have_unsaved_changes
-    end
-  end
-
   describe "#save!" do
-    it "should delegate to save" do
-      object.save_queue.should_receive(:save!).once
-      object.save!
-    end
-  end
-
-  describe "#save" do
-    it "should save queue" do
-      object.save_queue.should_receive(:save).once
-      object.save
-    end
+    context "object" do
+      it "should call #save! on queue" do
+        object.save_queue.should_receive(:save!).once
+        object.save!
+      end
 
-    it "should save itself" do
-      klass = Class.new do
-        def save
-          "saved!"
+      context "original class has #save! method defined" do
+        it "should call that method" do
+          object =
+            Class.new do
+              include SaveQueue::Object
+              attr_reader :save_called
+              def save!
+                @save_called = true
+              end
+            end.new
+
+          expect{ object.save! }.to change { object.save_called }.from(nil).to(true)
         end
-      end
 
-      klass.send :include, SaveQueue::Object
-      klass.new.save.should == "saved!"
-    end
+        #it "call #save! 5 time in a row should call super#save! 5 times" do
+        #  object = new_count_object
+        #  expect do
+        #    5.times { object.save }
+        #  end.to change { object.save_call_count }.from(0).to(5)
+        #end
+
+        context "and it raises an Exception" do
+          let(:object) do
+            Class.new do
+              include SaveQueue::Object
+              def save!
+                raise RuntimeError
+              end
+            end.new
+          end
 
-    context "object could not be saved" do
-      let(:object) do
-        klass = Class.new do
-          def save
-            false
+          it "should raise an Exception" do
+            expect{ object.save! }.to raise_error(RuntimeError)
           end
-        end
-        klass.send :include, SaveQueue::Object
-        klass.new
-      end
-      
-      it "should return false" do
-        object.save.should == false
-      end
 
-      it "should not save queue" do
-        object.save_queue.should_not_receive(:save)
-        object.save
+          it "should not save queue" do
+            object.save_queue.should_not_receive(:save)
+            object.save! rescue nil
+          end
+        end
       end
     end
 
-    
-    it "should not circle" do
-      other_object = new_object
-
-      object.mark_as_changed
-      other_object.mark_as_changed
-
-
-      object      .save_queue.add other_object
-      other_object.save_queue.add object
+    #it "should not circle" do
+    #  object       = new_count_object
+    #  other_object = new_count_object
+    #
+    #  object.save_queue.add other_object
+    #  other_object.save_queue.add object
+    #
+    #  other_object.save.should be_true
+    #
+    #  other_object.save_call_count.should == 1
+    #        object.save_call_count.should == 1
+    #end
 
-      $object_counter = mock :counter
-      $object_counter.should_receive(:increment).once
+  end
 
-      def object.save
-        result = super
-        $object_counter.increment
+  describe "#save" do
 
-        result
+    context "object" do
+      it "should save queue" do
+        object.save_queue.should_receive(:save).once
+        object.save
       end
 
-      $other_object_counter = mock :counter
-      $other_object_counter.should_receive(:increment).once
-
-      def other_object.save
-        result = super
-        $other_object_counter.increment
+      context "original class has #save method defined" do
+        it "should call that method (save object)" do
+          object =
+            Class.new do
+              include SaveQueue::Object
+              attr_reader :save_called
+              def save
+                @save_called = true
+              end
+            end.new
+
+          expect{ object.save }.to change { object.save_called }.from(nil).to(true)
+        end
 
-        result
-      end
+        it "call #save 5 time in a row should call super#save 5 times" do
+          object = new_count_object
 
-      #object.should_receive(:save).once.and_return(true)
-      #@base.should_receive(:save).once.and_return(true)
-      other_object.save.should be_true
-    end
+          expect do
+            5.times { object.save }
+          end.to change { object.save_call_count }.from(0).to(5)
+        end
 
-    describe "multiple queues" do
-      let(:other_object) { new_object }
+        context "and it return false" do
+          let(:object) { object_that_return(false) }
 
-      it "should save object only once" do
-        target = new_object
-        target.mark_as_changed
+          it "should return false" do
+            object.save.should be_false
+          end
 
-        object      .save_queue.add target
-        other_object.save_queue.add target
+          it "should not save queue" do
+            object.save_queue.should_not_receive(:save)
+            object.save
+          end
+        end
 
-        $counter = mock :counter
-        $counter.should_receive(:increment).once
+        context "and it return true" do
+          let(:object) { object_that_return(true) }
 
-        def target.save
-          result = super
-          $counter.increment
+          it "should return true if queue saved successfully" do
+            object.save.should be_true
+          end
 
-          result
+          it "should return false if queue not saved successfully" do
+            object.save_queue.stub(:save => false)
+            object.save.should be_false
+          end
         end
 
-        #target.should_receive(:save).once.and_return(true)
-        object.save.should be_true
-        other_object.save.should be_true
-      end
-    end
-  end
+        context "and it return nil" do
+          let(:object) { object_that_return(nil) }
 
-  describe "queue" do
-    let(:queue_class)       { Class.new(SaveQueue::ObjectQueue) }
-    let(:other_queue_class) { Class.new(SaveQueue::ObjectQueue) }
+          it "should return true if queue saved successfully" do
+            object.save.should eq true
+          end
 
-    it "should mapped to SaveQueue::ObjectQueue by default" do
-      klass = new_class
-      klass.queue_class.should be SaveQueue::ObjectQueue
-    end
+          it "should return false if queue not saved successfully" do
+            object.save_queue.stub(:save => false)
+            object.save.should eq false
+          end
+        end
 
-    describe "queue class change" do
-      it "before initialization should be possible" do
-        klass = new_class
-        klass.queue_class = other_queue_class
-        klass.new.save_queue.should be_kind_of other_queue_class
-      end
+        context "and it return not a boolean value" do
+          let(:object) { object_that_return("some string") }
 
-      it "after initialization should not affect already created queue" do
-        klass = new_class
-        klass.queue_class = queue_class
-        object = klass.new
-        
-        object.save_queue.should     be_a       queue_class
-        object.class.queue_class     =          other_queue_class
-        object.save_queue.should_not be_kind_of other_queue_class
-        object.save_queue.should     be_a       queue_class
-      end
+          it "should return object#save result if queue saved successfully" do
+            object.save.should == "some string"
+          end
 
-      it "should check dependencies for Hooks module" do
-        klass = new_class
-        expect{ klass.queue_class = Class.new }.to raise_error(RuntimeError, /Hooks/)
+          it "should return false if queue not saved successfully" do
+            object.save_queue.stub(:save => false)
+            object.save.should eq false
+          end
+        end
       end
     end
 
-    describe "inheritance" do
-      let(:klass)             { new_class }
-      
-      it "should inherit settings of parent class" do
-        klass.queue_class = queue_class
-
-        child = Class.new(klass)
-        child.queue_class.should == queue_class
-      end
-
-      it "should not override settings of parent class" do
-        klass.queue_class = queue_class
-
-        child = Class.new(klass)
-        child.queue_class = other_queue_class
-        child.queue_class.should == other_queue_class
-
-        klass.queue_class.should == queue_class
-      end
+    it "should not circle" do
+      object       = new_count_object
+      other_object = new_count_object
 
+      object.save_queue.add other_object
+      other_object.save_queue.add object
 
-      it "include SaveQueue::Object should not override settings of parent class" do
-        klass.queue_class = queue_class
+      other_object.save.should be_true
 
-        child = Class.new(klass)
-        child.send :include, SaveQueue::Object
-        child.queue_class.should == queue_class
-      end
+      other_object.save_call_count.should == 1
+            object.save_call_count.should == 1
     end
   end
 end

data/spec/save_queue_spec.rb

@@ -10,66 +10,4 @@ describe SaveQueue do
       klass.should include SaveQueue::Object
     end
   end
-
-  describe "functional" do
-    it "README example should work" do
-      article = Article.new
-      
-      tag_objects = []
-      3.times do
-        tag = Tag.new
-        tag.change_attribute :title, "new tag"
-        tag.should_receive(:save).once
-        tag_objects << tag
-      end
-      article.tags = tag_objects
-
-      tag = Tag.new
-      tag.change_attribute :title, "single tag"
-      tag.should_receive(:save).once
-      article.add_tag tag
-
-      # that will save article and all tags in this article if article
-      # and tags are valid, and if article.save and all tag.save returns true
-      # You may also use #save! method, that will trigger save_queue.save! and
-      # raise SaveQueue::FailedSaveError on fail
-      article.save.should be_true
-    end
-  end
-end
-
-
-
-require 'save_queue'
-class Article
-  include SaveQueue
-
-  def change_attribute attr, value
-    @attributes ||= {}
-    @attributes[attr] = value
-    mark_as_changed # call this and object will be marked for save
-  end
-
-  def tags= tag_objects
-    @tags = tag_objects
-    mark_as_changed
-    save_queue.add_all tag_objects
-  end
-
-  def add_tag tag
-    @tags ||= []
-    @tags << tag
-    save_queue.add tag # or use <<, push methods
-  end
-end
-
-
-class Tag
-  include SaveQueue
-
-  def change_attribute attr, value
-    @attributes ||= {}
-    @attributes[attr] = value
-    mark_as_changed # call this and object will be marked for save
-  end
 end

data/spec/support/object_helpers.rb

@@ -7,4 +7,35 @@ def new_class
   klass.send :include, SaveQueue::Object
 
   klass
+end
+
+def changed_object_for(klass)
+  object = klass.new
+  object.mark_as_changed
+  object
+end
+
+def new_count_object
+  target_class = new_class
+  target_class.send :include, Count_mod
+  target_class.new
+end
+
+module Count_mod
+  def save_call_count
+    @save_call_count.to_i
+  end
+
+  def save
+    @save_call_count ||= 0
+    @save_call_count += 1
+  end
+end
+
+def object_that_return(value = nil, &block)
+  Class.new do
+    include SaveQueue::Object
+    s = block_given? ? block : lambda { value }
+    define_method :save, &s
+  end.new
 end

data/spec/support/queue_helpers.rb

@@ -7,7 +7,6 @@ end
 def new_element(name = :element, options = {})
   element = stub(name)
   element.stub(:save).and_return(options.has_key?(:saved) ? options[:saved] : true)
-  element.stub(:has_unsaved_changes?).and_return(options.has_key?(:changed) ? options[:changed] : true)
 
   element
 end
@@ -24,3 +23,6 @@ def new_queue_class(options = {})
 
   queue_class
 end
+
+
+ADD_METHODS = %w[add << push]