memento 0.3.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,117 @@
+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
+  
+  context "undo" do
+    before do
+      @state1 = @session.states.create!(:action_type => "update", :record => @p1 = Project.create!)
+      @other = 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
+        Memento::State.count.should eql(3)
+      end
+      
+      it "should keep itself" do
+        @session.undo
+        @session.reload
+      end
+      
+      it "should raise Memento::ErrorOnRewind on undo!" 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 when using undo!" do
+        @session.undo! rescue
+        Memento::State.count.should eql(3)
+      end
+      
+      it "should NOT keep all states when using undo" do
+        @session.undo
+        Memento::State.count.should eql(2)
+      end
+
+      it "should keep itself" do
+        @session.undo rescue nil
+        @session.reload
+      end
+      
+      it "should raise Memento::ErrorOnRewind on undo!" 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,55 @@
+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
+  end
+  
+  after do
+    shutdown_db
+  end
+  
+end

data/spec/memento_spec.rb

@@ -0,0 +1,169 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Memento do
+  before do
+    setup_db
+    setup_data
+  end
+  
+  after do
+    shutdown_db
+  end
+  
+  it "should be a singleton" do
+    Memento.instance.should be_kind_of(Singleton)
+    Memento.instance.should eql(Memento.instance)
+    lambda{ Memento.new }.should raise_error(NoMethodError)
+  end
+  
+  it "should not be memento by default" do
+    Memento.instance.should_not be_active
+  end
+  
+  describe "start" do
+    
+    before do
+      Memento.instance.start(@user)
+      @session = Memento.instance.instance_variable_get("@session")
+    end
+    
+    it "should require user or user_id on start" do
+      lambda{ Memento.instance.start }.should raise_error(ArgumentError)
+    end
+    
+    it "should set an unsaved memento_session when starting" do
+      Memento::Session.count.should eql(0)
+      @session.should be_kind_of(Memento::Session)
+      @session.should be_new_record
+    end
+    
+    it "should set user on session" do
+      @session.user.should eql(User.first)
+    end
+    
+    it "should set user when passing in id as integer" do
+      Memento.instance.start(User.create(:name => "MyUser2").id)
+      Memento.instance.instance_variable_get("@session").user.should eql(User.last)
+    end
+    
+    it "should not start memento when user does not exists/is invalid" do
+      Memento.instance.stop
+      Memento.instance.start(123333)
+      Memento.instance.should_not be_active
+      Memento.instance.start("123")
+      Memento.instance.should_not be_active
+    end
+    
+    it "should be memento" do
+      Memento.instance.should be_active
+    end
+    
+  end
+  
+  describe "stop" do
+    before do
+      Memento.instance.start(@user)
+      Memento.instance.stop
+    end
+    
+    it "should not be memento" do
+      Memento.instance.should_not be_active
+    end
+    
+    it "should remove session if no states created" do
+      Memento::Session.count.should eql(0)
+    end
+  end
+  
+  describe "memento block" do
+    
+    it "should record inside of block and stop after" do
+      Memento.instance.should_not be_active
+      Memento.instance.memento(@user) do
+        Memento.instance.should be_active
+      end
+      Memento.instance.should_not be_active
+    end
+    
+    it "should give back session when states created" do
+      Memento.instance.memento(@user) do
+        Project.create!
+      end.should be_a(Memento::Session)
+    end
+    
+    it "should give back false when no states created" do
+      Memento.instance.memento(@user) do
+        1 + 1
+      end.should be_false
+    end
+    
+    it "should raise error in block and stop session" do
+      lambda {
+        Memento.instance.memento(@user) do
+          raise StandardError
+        end.should be_nil
+      }.should raise_error(StandardError)
+      Memento.instance.should_not be_active
+    end
+    
+  end
+  
+  describe "when active" do
+    before do
+      @project =  Project.create(:name => "P1")
+      Memento.instance.start(@user)
+    end
+    
+    after do
+      Memento.instance.stop
+    end
+    
+    it "should create memento_state for ar-object with action_type" do
+      Memento::State.count.should eql(0)
+      Memento.instance.add_state :destroy, @project
+      Memento::State.count.should eql(1)
+      Memento::State.first.action_type.should eql("destroy")
+      Memento::State.first.record.should eql(Project.last)
+    end
+    
+    it "should save session on first added state" do
+      Memento::Session.count.should eql(0)
+      Memento.instance.add_state :destroy, @project
+      Memento::Session.count.should eql(1)
+    end
+    
+    describe "when ignoring" do
+      it "should NOT create memento_state for ar-object with action_type" do
+        Memento.instance.ignore do
+          Memento.instance.add_state :destroy, Project.create(:name => "P1")
+        end
+        
+        Memento::State.count.should eql(0)
+      end
+    end
+    
+  end
+  
+  describe "when not active" do
+    
+    it "should NOT create memento_state for ar-object with action_type" do
+      Memento.instance.add_state :destroy, Project.create(:name => "P1")
+      Memento::State.count.should eql(0)
+    end
+    
+  end
+  
+  context "serializer" do
+    
+    it "should default to yaml" do
+      Memento.serializer.should eql(YAML)
+    end
+    
+    it "should be changeable" do
+      Memento.serializer = Marshal
+      Memento.serializer.should eql(Marshal)
+    end
+    
+  end
+  
+end