Add specs for Queue. Split it to UniqQueue and ObjectQueue

Author: AlexParamonov

lib/save_queue.rb

@@ -1,5 +1,5 @@
 require "save_queue/version"
-require "save_queue/object"
+#require "save_queue/object"
 
 module SaveQueue
   def self.included base

lib/save_queue/object_queue.rb

@@ -0,0 +1,50 @@
+require 'forwardable'
+require 'save_queue/uniq_queue'
+
+module SaveQueue
+  class ObjectQueue < UniqQueue
+    def add object
+      check_requirements_for object
+      super object
+    end
+
+    def save
+      saved     = []
+      processed = []
+
+      @queue.each do |object|
+        if object.has_unsaved_changes?
+
+          result = object.save
+          raise FailedSaveError, {:processed => processed, :saved => saved, :failed => object, :pending => @queue - (saved + [object])} if false == result
+
+          saved << object
+        end
+        processed << object
+      end
+
+      @queue.clear
+
+      true
+    end
+
+
+    private
+    def check_requirements_for object
+      [:save, :has_unsaved_changes?].each do |method|
+        raise ArgumentError, "#{object.inspect} does not respond to ##{method}" unless object.respond_to? method
+      end
+    end
+  end
+
+  class FailedSaveError < RuntimeError
+    attr_reader :context
+    def initialize(context_hash)
+      @context = context_hash
+    end
+
+    def to_s # Some default way to display errors
+      "#{super}: " + @context.to_s
+    end
+  end
+end

lib/save_queue/queue.rb

@@ -0,0 +1,33 @@
+require 'forwardable'
+module SaveQueue
+  class UniqQueue
+    extend ::Forwardable
+    DELEGATED_METHODS = [:empty?,
+                         :size,
+                         :count,
+                         :clear,
+                         :inspect,
+                         :to_s,
+                         :last,
+                         :pop,
+                         :shift]
+
+    def_delegators :@queue, *DELEGATED_METHODS
+    
+    def initialize
+      @queue = []
+    end
+
+    def add_all objects
+      Array(objects).each do |object|
+        add object
+      end
+    end
+
+    def add object
+      @queue << object unless @queue.include? object
+    end
+    alias_method :push, :add
+    alias_method :<<,   :add
+  end
+end

lib/save_queue/uniq_queue.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "save_queue/objects_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 not accept objects that does not respond to #save" do
+        element.unstub(:save)
+        expect{ queue.add 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.add element }.to raise_error ArgumentError, "#{element.inspect} does not respond to #has_unsaved_changes?"
+      end
+    end
+  end
+
+  describe "#save" do
+    it "should save all object in queue" do
+      5.times do
+        element = stub(:element)
+        element.stub(:has_unsaved_changes?).and_return(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 raise SaveQueue::FailedSaveError if at least one object in queue was not saved" do
+      objects ={}
+      objects[:valid1]               = new_element(:valid1)
+      objects[:valid2]               = new_element(:valid2)
+      objects[:not_changed]          = new_element(:not_changed,         :changed => false, :saved => true)
+      objects[:unsaved_but_changed]  = new_element(:unsaved_but_changed, :changed => true,  :saved => false)
+      objects[:saved]                = new_element(:saved,               :changed => true,  :saved => true)
+      objects[:valid3]               = new_element(:valid3)
+
+      objects.each_value do |object|
+        queue << object
+      end
+
+
+      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
+end

spec/objects_queue_spec.rb

@@ -0,0 +1,13 @@
+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

spec/support/mock_helpers.rb

@@ -0,0 +1,123 @@
+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
+      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
+        element = new_element
+        queue.should be_empty
+
+        queue.send(method, element)
+        queue.should have(1).elements
+
+        queue.send(method, element)
+        queue.should have(1).elements
+      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|
+      describe "##{method}" do
+        it "should delegate to @queue##{method}" do
+          queue_var.should_receive(method).once
+          queue.send method
+        end
+      end
+    end
+  end
+end