yolk-memento 0.2.0

data/spec/memento/action_controller_methods_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+class FooController < ActionController::Base
+  
+  private
+  
+end
+
+describe Memento::ActionControllerMethods do
+  
+  before do
+    setup_db
+    setup_data
+    @controller = FooController.new
+    @controller.stub!(:current_user).and_return(@user)
+    @headers = {}
+    @controller.stub!(:response).and_return(mock("response", :headers => @headers))
+  end
+  
+  after do
+    shutdown_db
+  end
+  
+  it "should add memento-method to ActionController::Base" do
+    FooController.private_instance_methods.should include("memento")
+  end
+  
+  it "should call memento#memento with user and block" do
+    project = Project.create!
+    @controller.send(:memento) do
+      project.update_attribute(:name, "P7")
+    end
+    project.reload.name.should eql("P7")
+    project.memento_states.count.should eql(1)
+    Memento::Session.count.should eql(1)
+  end
+  
+  it "should set header X-MementoSessionId" do
+    @controller.send(:memento) { Project.create!.update_attribute(:name, "P7") }
+    @headers.should == {'X-Memento-Session-Id' => Memento::Session.last.id.to_s }
+  end
+  
+  it "should return result of given block" do
+    @controller.send(:memento) do
+      1 + 2
+    end.should eql(3)
+  end
+  
+  it "should not set header when no session stored" do
+    @controller.send(:memento) { Customer.create! } # not stored
+    @headers['X-MementoSessionId'].should be_nil
+    @headers.should_not have_key('X-Memento-Session-Id')
+  end
+  
+end

data/spec/memento/active_record_methods_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Memento::ActiveRecordMethods do
+  
+  before do
+    setup_db
+    setup_data
+  end
+  
+  it "should declare private methods on Project" do
+    Project.private_instance_methods.should include("record_destroy", "record_update", "record_create")
+  end
+  
+  it "should set hook on create to call Memento" do
+    project = Project.new(:name => "Project X")
+    Memento.instance.should_receive(:add_state).once().with("create", project)
+    project.save!
+  end
+  
+  it "should set hook on update to call Memento" do
+    project = Project.create!(:name => "Project X")
+    Memento.instance.should_receive(:add_state).once().with("update", project)
+    project.update_attribute(:name, "Project XY")
+  end
+  
+  it "should set hook on destroy to call Memento" do
+    project = Project.create!(:name => "Project X")
+    Memento.instance.should_receive(:add_state).once().with("destroy", project)
+    project.destroy
+  end
+  
+  it "should define attributes_for_memento and ignore attributes given by options" do
+    Project.create!(:name => "Project X").attributes_for_memento.should == {
+      "id"=>1, "name"=>"Project X", "notes"=>nil, "customer_id"=>nil, "closed_at"=>nil
+    }
+  end
+  
+  it "should define changes_for_memento and ignore attributes given by options" do
+    project = Project.create!(:name => "Project X")
+    project.name = "A Project"
+    project.updated_at = 5.minutes.ago
+    project.notes = "new"
+    project.ignore_this = 2
+    project.changes_for_memento.should_not == project.changes
+    project.changes_for_memento.should == {"name"=>["Project X", "A Project"], "notes"=>[nil, "new"]}
+  end
+  
+  it "should define has_many association to memento_states" do
+    project = Project.create!(:name => "Project X")
+    project.memento_states.should be_empty
+    Memento.instance.memento(@user) { project.update_attribute(:name, "Project Y") }
+    project.memento_states.count.should eql(1)
+    Memento.instance.memento(@user) { project.update_attribute(:name, "Project Y") }
+    project.memento_states.count.should eql(1)
+    Memento.instance.memento(@user) { Project.create!.update_attribute(:name, "Project X") }
+    project.memento_states.count.should eql(1)
+    Project.last.memento_states.count.should eql(2)
+    Memento::State.count.should eql(3)
+  end
+  
+  after do
+    shutdown_db
+  end
+  
+end

data/spec/memento/result_spec.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Memento::Result do
+  
+  describe "when initalized with valid object" do
+    before do
+      @object = mock("object", :errors => {})
+      @state = mock("state1")
+      @result = Memento::Result.new(@object, @state)
+    end
+
+    it "should have an object attribute" do
+      @result.object.should eql(@object)
+    end
+    
+    it "should have an state attribute" do
+      @result.state.should eql(@state)
+    end
+
+    it "should have an error attribute" do
+      @result.error.should be_nil
+    end
+
+    it "should be valid" do
+      @result.should be_success
+      @result.should_not be_failed
+    end
+  end
+  
+  describe "when initalized with object with errors" do
+    before do
+      @object = mock("object", :errors => {:memento_undo => "123"})
+      @result = Memento::Result.new(@object, mock("state1"))
+    end
+    
+    it "should have an object attribute" do
+      @result.object.should eql(@object)
+    end
+
+    it "should return error" do
+      @result.error.should eql("123")
+    end
+
+    it "should be invalid" do
+      @result.should be_failed
+      @result.should_not be_success
+    end
+  end
+
+end
+
+describe Memento::ResultArray do
+  
+  before do
+    @results = Memento::ResultArray.new()
+  end
+  
+  it "should have an empty errors array" do
+    @results.errors.should eql([])
+  end
+  
+  it "should have no errors" do
+    @results.should be_success
+    @results.should_not be_failed
+  end
+  
+  describe "when Memento::Result without errors added" do
+    before do
+      @object = mock("object", :errors => {:memento_undo => "123"})
+      @results << Memento::Result.new(mock("object2", :errors => {}), mock("state1"))
+      @results << (@with_error = Memento::Result.new(@object, mock("state2")))
+    end
+    
+    it "should have two entrys" do
+      @results.size.should eql(2)
+    end
+    
+    it "should have one error" do
+      @results.errors.size.should eql(1)
+      @results.errors.should eql([@with_error])
+    end
+    
+    it "should have an error" do
+      @results.should_not be_success
+      @results.should be_failed
+    end
+  end
+  
+end

data/spec/memento/session_spec.rb

@@ -0,0 +1,181 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Memento::Session do
+  
+  before do
+    setup_db
+    setup_data
+    @session = Memento::Session.create(:user => @user)
+  end
+  
+  it "should belong to user" do
+    @session.user.should eql(@user)
+  end
+  
+  it "should require user" do
+    Memento::Session.create.errors[:user].should eql("can't be blank")
+  end
+  
+  it "should have_many states" do
+    @session.states.should eql([])
+    @session.states.create!(:action_type => "destroy", :record => Project.create!)
+    @session.states.count.should eql(1)
+  end
+  
+  describe "on undo" do
+    before do
+      @states = [@t1 = mock("t1"), @t2 = mock("t2")]
+      @session.stub!(:states).and_return(@states)
+    end
+    
+    describe "and all states fail" do
+      before do
+        @t1.stub!(:undo).once().and_return(mock("r1", :success? => false))
+        @t2.stub!(:undo).once().and_return(mock("r2", :success? => false))
+        @states.stub!(:count).and_return(2)
+      end
+      
+      it "should call undo on all states when undo is called" do
+        @t1.should_receive(:undo).once().and_return(mock("r1", :success? => false))
+        @t2.should_receive(:undo).once().and_return(mock("r2", :success? => false))
+        @session.undo
+      end
+      
+      it "should kepp itself" do
+        @session.undo
+        @session.reload
+      end
+    end
+    
+    describe "and all states succeed" do
+      before do
+        @t1.stub!(:undo).once().and_return(mock("r1", :success? => true, :state => @t1))
+        @t2.stub!(:undo).once().and_return(mock("r2", :success? => true, :state => @t2))
+        @t1.stub!(:destroy).once()
+        @t2.stub!(:destroy).once()
+        @states.stub!(:count).and_return(0)
+      end
+      
+      it "should destroy itself" do
+        @session.undo
+        Memento::Session.find_by_id(@session.id).should be_nil
+      end
+      
+      it "should destroy all states" do
+        @t1.should_receive(:destroy).once()
+        @t2.should_receive(:destroy).once()
+        @session.undo
+      end
+    end
+    
+    describe "and some states succeed, some fail" do
+      before do
+        @t1.stub!(:undo).once().and_return(mock("r1", :success? => true, :state => @t1))
+        @t2.stub!(:undo).once().and_return(mock("r2", :success? => false, :state => @t2))
+        @t1.stub!(:destroy).once()
+        @states.stub!(:count).and_return(1)
+      end
+      
+      it "should kepp itself" do
+        @session.undo
+        @session.reload
+      end
+      
+      it "should destroy only successful states" do
+        @t1.should_receive(:destroy).once()
+        @t2.should_receive(:destroy).never()
+        @session.undo
+      end
+    end
+  end
+  
+  describe "on undo!" do
+    before do
+      @state1 = @session.states.create!(:action_type => "update", :record => @p1 = Project.create!)
+      Memento::Session.create!(:user => @user).states.create!(:action_type => "destroy", :record => Project.create!)
+      @state2 = @session.states.create!(:action_type => "update", :record => @p2 = Project.create!)
+    end
+    
+    describe "and all states succeed" do
+      it "should return ResultsArray" do
+        @session.undo!.should be_a(Memento::ResultArray)
+      end
+      
+      it "should remove all states" do
+        @session.undo!
+        Memento::State.count.should eql(1)
+      end
+      
+      it "should remove itself" do
+        @session.undo!
+        Memento::Session.find_by_id(@session.id).should be_nil
+      end
+    end
+    
+    describe "and all states fail" do
+      before do
+        @state1.update_attribute(:record_data, {:name => ["A", "B"]})
+        @p1.update_attribute(:name, "C")
+        @state2.update_attribute(:record_data, {:name => ["A", "B"]})
+        @p2.update_attribute(:name, "C")
+      end
+      
+      it "should keep all states" do
+        @session.undo! rescue
+        Memento::State.count.should eql(3)
+      end
+      
+      it "should keep itself" do
+        @session.undo! rescue
+        @session.reload
+      end
+      
+      it "should raise Memento::ErrorOnRewind" do
+        lambda{ @session.undo! }.should raise_error(Memento::ErrorOnRewind)
+      end
+    end
+    
+    describe "and some states succeed, some fail" do
+      before do
+        @state1.update_attribute(:record_data, {:name => ["A", "B"]})
+        @p1.update_attribute(:name, "C")
+      end
+
+      it "should keep all states" do
+        @session.undo! rescue nil
+        Memento::State.count.should eql(3)
+      end
+
+      it "should keep itself" do
+        @session.undo! rescue nil
+        @session.reload
+      end
+      
+      it "should raise Memento::ErrorOnRewind" do
+        lambda{ @session.undo! }.should raise_error(Memento::ErrorOnRewind)
+      end
+    end
+  end
+  
+  describe "with states" do
+    before do
+      @session.states.create!(:action_type => "destroy", :record => Project.create!)
+      Memento::Session.create!(:user => @user).states.create!(:action_type => "destroy", :record => Project.create!)
+      @state2 = @session.states.create!(:action_type => "update", :record => Project.create!)
+    end
+    
+    it "should destroy all states when destroyed" do
+      Memento::State.count.should eql(3)
+      @session.destroy
+      Memento::State.count.should eql(1)
+    end
+    
+  end
+  
+  
+  
+  after do
+    shutdown_db
+  end
+  
+end

data/spec/memento/state_spec.rb

@@ -0,0 +1,105 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Memento::State do
+  
+  before do
+    setup_db
+    setup_data
+    @session = Memento::Session.create(:user => @user)
+  end
+  
+  it "should belong to session" do
+    Memento::State.new(:session => @session).session.should eql(@session)
+  end
+  
+  it "should require session" do
+    Memento::State.create.errors[:session].should eql("can't be blank")
+  end
+  
+  it "should require action_type to be one of Memento::State::RECORD_CAUSES" do
+    Memento::State.create.errors[:action_type].should eql("can't be blank")
+    Memento::State.create(:action_type => "move").errors[:action_type].should eql("is not included in the list")
+  end
+  
+  it "should belong to polymorphic record" do
+    Memento::State.new(:record => @user).record.should eql(@user)
+    Memento::State.new(:record => @session).record.should eql(@session)
+  end
+  
+  it "should require record" do
+    Memento::State.create.errors[:record].should eql("can't be blank")
+  end
+  
+  
+  describe "valid State" do
+    before do
+      @state = @session.states.create!(:action_type => "destroy", :record => @project = Project.create(:name => "A") )
+    end
+    
+    it "should give back Memento::Result on undo" do
+      result = @state.undo
+      result.should be_a(Memento::Result)
+      result.object.should be_a(Project)
+      result.state.should eql(@state)
+    end
+    
+    it "should give back old data on record_data" do
+      @state.record_data.should == (@project.attributes_for_memento)
+    end
+    
+    it "should give back new unsaved copy of object on new_object" do
+      @state.new_object.should be_kind_of(Project)
+      @state.new_object.name.should be_nil
+      @state.new_object do |object|
+        object.name = "B"
+      end.name.should eql("B")
+    end
+    
+    it "should give back new unsaved copy filled with old data of object on rebuild_object" do
+      @state.rebuild_object.should be_kind_of(Project)
+      @state.rebuild_object.name.should eql("A")
+      @state.rebuild_object(:id).id.should be_nil # skip id
+      @state.rebuild_object.id.should eql(@project.id)
+      @state.rebuild_object do |object|
+        object.name = "B"
+      end.name.should eql("B")
+    end
+    
+    describe "on later_states_on_record_for" do
+      
+      it "should return empty array" do
+        @state.later_states_on_record_for("destroy").should eql([])
+      end
+
+      it "should return filled array when other record of the given action_type exists" do
+        Memento::Session.create!(:user => @user).states.create!(:action_type => "destroy", :record => @project )
+        @state.later_states_on_record_for("destroy").map(&:class).should eql([Memento::State])
+        @state.later_states_on_record_for(:"destroy").map(&:id).should eql([2])
+      end
+      
+      it "should return empty array when only records of another action_type exists" do
+        Memento::Session.create!(:user => @user).states.create!(:action_type => "update", :record => @project )
+        @state.later_states_on_record_for("destroy").should eql([])
+      end
+      
+      it "should return empty array when only destroy records of another record exists" do
+        Memento::Session.create!(:user => @user).states.create!(:action_type => "destroy", :record => Project.create(:name => "B") )
+        @state.later_states_on_record_for("destroy").should eql([])
+      end
+      
+      it "should return empty array when only destroy records older than @tack exist" do
+        state2 = Memento::Session.create!(:user => @user).states.create!(:action_type => "destroy", :record => @project )
+        state2.update_attribute(:created_at, 3.minutes.ago)
+        @state.later_states_on_record_for("destroy").should eql([])
+      end
+    end
+    
+    
+    
+  end
+  
+  after do
+    shutdown_db
+  end
+  
+end