save_queue 0.2.3 → 0.3.0

data/spec/notification/object_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "save_queue/plugins/notification/object"
+
+class NotifyObject
+  include SaveQueue
+  include SaveQueue::Plugins::Notification::Object
+end
+
+describe SaveQueue::Plugins::Notification::Object do
+
+  it "should register observer on queue to #queue_changed_event method" do
+    NotifyObject.queue_class.any_instance.should_receive(:add_observer).with do |observer, method|
+      observer.is_a?(NotifyObject) and method == :queue_changed_event
+    end
+    NotifyObject.new
+  end
+
+  let(:queue) do
+    queue_class = Class.new
+    queue_class.stub(:include?).with(Hooks).and_return(true)
+
+    queue_class
+  end
+  
+  it "should raise an exception if queue does not respond to #add_observer" do
+    queue.any_instance.stub(:respond_to?).with(:add_observer).and_return(false)
+    NotifyObject.queue_class = queue
+    expect { NotifyObject.new }.to raise_error(RuntimeError, /add_observer/)
+  end
+
+  it "should not raise an exception if queue respond to #add_observer" do
+    queue.any_instance.stub(:respond_to?).with(:add_observer).and_return(true)
+    queue.any_instance.stub(:add_observer)
+    NotifyObject.queue_class = queue
+    expect { NotifyObject.new }.to_not raise_error
+  end
+  
+  describe "#queue_changed_event" do
+    let(:object) do
+      NotifyObject.any_instance.stub(:create_queue)
+      NotifyObject.new
+    end
+
+    it "should mark self as changed" do
+      object.should_receive(:mark_as_changed)
+      object.send :queue_changed_event, true, stub(:some_object)
+    end
+    
+    it "should not mark self as changed if result of adding element to a queue was false" do
+      object.should_not_receive(:mark_as_changed)
+      object.send :queue_changed_event, false, stub(:some_object)
+    end
+  end
+end

data/spec/notification/queue_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "save_queue/plugins/notification/queue"
+
+class NotifyQueue < SaveQueue::ObjectQueue
+  include SaveQueue::Plugins::Notification::Queue
+end
+
+describe SaveQueue::Plugins::Notification::Queue do
+  let(:queue) { NotifyQueue.new }
+
+  [:add, :<<, :push].each do |method|
+    describe "##{method}" do
+      let(:element) { new_element }
+      
+      it "should notify observers about change" do
+        queue.should_receive(:changed)
+        queue.should_receive(:notify_observers)
+        queue.send method, element
+      end
+
+      it "should notify observer, provided result of a method call and input object" do
+        queue.should_receive(:changed)
+        queue.should_receive(:notify_observers).with(true, element)
+        queue.send method, element
+      end
+    end
+  end
+end

data/spec/object_queue_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "save_queue/object_queue"
+
+describe SaveQueue::ObjectQueue do
+  let(:queue)   { SaveQueue::ObjectQueue.new }
+  let(:element) { new_element(:element)       }
+
+  [:add, :<<, :push].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)
+        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)
+        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
+      5.times do
+        element = stub(:element, :has_unsaved_changes? => true)
+        element.should_receive(:save).once
+        queue << element
+      end
+
+      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
+    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)
+
+      queue << element
+      queue.save
+    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)
+
+      element.should_receive(:save).once.and_return(true)
+      queue.save
+    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)
+    end
+
+    describe "#save!" do
+      it "should set errors" do
+        expect {queue.save!}.to raise_error
+
+        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) }
+      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) }
+        }
+      end
+    end
+
+    describe "#save" do
+      it "should return false" do
+        queue.save.should be_false
+      end
+
+      it "should set errors" 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) }
+      end
+      
+      it "should not raise SaveQueue::FailedSaveError" do
+        expect{  queue.save }.not_to raise_error(SaveQueue::FailedSaveError)
+      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)
+      end
+
+      it "should save all pending objects" do
+        @objects.values_at(:saved, :valid3).each 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
+      end
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,208 @@
+require "spec_helper"
+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
+
+    it "should save itself" do
+      klass = Class.new do
+        def save
+          "saved!"
+        end
+      end
+
+      klass.send :include, SaveQueue::Object
+      klass.new.save.should == "saved!"
+    end
+
+    context "object could not be saved" do
+      let(:object) do
+        klass = Class.new do
+          def save
+            false
+          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
+      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
+
+      $object_counter = mock :counter
+      $object_counter.should_receive(:increment).once
+
+      def object.save
+        result = super
+        $object_counter.increment
+
+        result
+      end
+
+      $other_object_counter = mock :counter
+      $other_object_counter.should_receive(:increment).once
+
+      def other_object.save
+        result = super
+        $other_object_counter.increment
+
+        result
+      end
+
+      #object.should_receive(:save).once.and_return(true)
+      #@base.should_receive(:save).once.and_return(true)
+      other_object.save.should be_true
+    end
+
+    describe "multiple queues" do
+      let(:other_object) { new_object }
+
+      it "should save object only once" do
+        target = new_object
+        target.mark_as_changed
+
+        object      .save_queue.add target
+        other_object.save_queue.add target
+
+        $counter = mock :counter
+        $counter.should_receive(:increment).once
+
+        def target.save
+          result = super
+          $counter.increment
+
+          result
+        end
+
+        #target.should_receive(:save).once.and_return(true)
+        object.save.should be_true
+        other_object.save.should be_true
+      end
+    end
+  end
+
+  describe "queue" do
+    let(:queue_class)       { Class.new(SaveQueue::ObjectQueue) }
+    let(:other_queue_class) { Class.new(SaveQueue::ObjectQueue) }
+
+    it "should mapped to SaveQueue::ObjectQueue by default" do
+      klass = new_class
+      klass.queue_class.should be SaveQueue::ObjectQueue
+    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
+
+      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 check dependencies for Hooks module" do
+        klass = new_class
+        expect{ klass.queue_class = Class.new }.to raise_error(RuntimeError, /Hooks/)
+      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 "include SaveQueue::Object should not override settings of parent class" do
+        klass.queue_class = queue_class
+
+        child = Class.new(klass)
+        child.send :include, SaveQueue::Object
+        child.queue_class.should == queue_class
+      end
+    end
+  end
+end

data/spec/save_queue_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "save_queue/object"
+
+describe SaveQueue do
+  describe "#include" do
+    it "should include SaveQueue::Object" do
+      klass = Class.new
+      klass.send :include, SaveQueue
+
+      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

@@ -0,0 +1,10 @@
+def new_object
+  new_class.new
+end
+
+def new_class
+  klass = Class.new
+  klass.send :include, SaveQueue::Object
+
+  klass
+end

data/spec/support/queue_helpers.rb

@@ -0,0 +1,26 @@
+def fill_queue
+  5.times do
+    queue << new_element
+  end
+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
+
+def new_velement(options = {:valid => true})
+  object = new_element
+  object.stub(:valid?).and_return(options[:valid])
+  object
+end
+
+def new_queue_class(options = {})
+  queue_class = Class.new
+  queue_class.stub(:include?).with(Hooks).and_return(true)
+
+  queue_class
+end

data/spec/uniq_queue_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+require "save_queue/uniq_queue"
+
+describe SaveQueue::UniqQueue do
+  let(:queue)   { SaveQueue::UniqQueue.new }
+  #let(:element) { new_element(:element)    }
+
+  [:size, :count].each do |method|
+    describe "##{method}" do
+      it "should return 0 for empty queue" do
+        queue.send(method).should be_zero
+      end
+
+      it "should count elements in queue" do
+        3.times do
+          queue << new_element
+        end
+
+        queue.send(method).should == 3
+      end
+    end
+  end
+
+  describe "#new" do
+    it "should be empty queue" do
+      queue.should have(0).elements
+      queue.should be_empty
+    end
+  end
+
+  [:add, :<<, :push].each do |method|
+    describe "##{method}" do
+      let(:element) { new_element }
+      it "should add object to a queue" do
+        queue.should be_empty
+
+        queue.send(method, new_element)
+        queue.should_not be_empty
+        queue.should have(1).elements
+
+        queue.send(method, new_element)
+        queue.should_not be_empty
+        queue.should have(2).elements
+      end
+
+      it "should add object to a queue once" do
+        queue.should be_empty
+
+        queue.send(method, element)
+        queue.should have(1).elements
+
+        queue.send(method, element)
+        queue.should have(1).elements
+      end
+
+      it "should return true" do
+        queue.send(method, element).should === true
+      end
+
+      it "should return false if element was not added" do
+        queue.send(method, element)
+        queue.should have(1).elements
+        
+        queue.send(method, element).should === false
+      end
+    end
+  end
+
+  describe "#add_all" do
+    it "should delegate to #add" do
+      queue.should_receive(:add).exactly(3).times
+      queue.add_all [1,2,3]
+    end
+
+    it "should act as #add if single argument passed" do
+      queue.should_receive(:add).once
+      queue.add_all 1
+    end
+  end
+
+
+  describe "#clear" do
+    it "should clear the queue" do
+      fill_queue
+      #expect{ queue.clear }.to change{ queue.count }.from(5).to(0)
+      queue.should_not be_empty
+      queue.clear
+      queue.should be_empty
+    end
+  end
+
+  describe "#pop" do
+    it "should remove last element from queue and return it back" do
+      queue << new_element(:first)
+      queue << new_element
+      queue << new_element
+      last = new_element(:last)
+      queue << last
+
+      result = nil
+      expect{ result = queue.pop }.to change{ queue.count }.by(-1)
+      result.should_not be_nil
+      result.should be last
+    end
+  end
+
+  describe "#shift" do
+    it "should remove first element from queue and return it back" do
+      first = new_element(:first)
+      queue << first
+      queue << new_element
+      queue << new_element
+      queue << new_element(:last)
+
+      result = nil
+      expect{ result = queue.shift }.to change{ queue.count }.by(-1)
+      result.should_not be_nil
+      result.should be first
+    end
+  end
+
+  describe "delegates" do
+    let(:queue_var) { queue.instance_variable_get("@queue") }
+
+    SaveQueue::UniqQueue::DELEGATED_METHODS.each do |method|
+      it "##{method}\tshould delegate to @queue##{method}" do
+        queue_var.should_receive(method).once
+        queue.send method
+      end
+    end
+  end
+end