simple_state_machine 0.6.0 → 0.6.1

data/spec/active_record_spec.rb

@@ -1,253 +1,250 @@
 require 'spec_helper'
-
-ActiveRecord::Base.logger = Logger.new "test.log"
-ActiveRecord::Base.establish_connection(:adapter  => "sqlite3",
-                                        :database => ":memory:")
-
-def setup_db
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :users do |t|
-      t.column :id,               :integer
-      t.column :name,             :string
-      t.column :state,            :string
-      t.column :activation_code,  :string
-      t.column :created_at,       :datetime
-      t.column :updated_at,       :datetime
-    end
-    create_table :tickets do |t|
-      t.column :id,         :integer
-      t.column :ssm_state,  :string
+require 'logger'
+
+if defined? ActiveRecord
+  ActiveRecord::Base.logger = Logger.new "test.log"
+  ActiveRecord::Base.establish_connection('adapter' => RUBY_PLATFORM == 'java' ? 'jdbcsqlite3' : 'sqlite3', 'database' => ':memory:')
+
+  def setup_db
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :users do |t|
+        t.column :name,             :string
+        t.column :state,            :string
+        t.column :activation_code,  :string
+        t.column :created_at,       :datetime
+        t.column :updated_at,       :datetime
+      end
+      create_table :tickets do |t|
+        t.column :ssm_state,  :string
+      end
     end
   end
-end
-
-def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
-  end
-end
-
-class Ticket < ActiveRecord::Base
-  extend SimpleStateMachine::ActiveRecord
 
-  state_machine_definition.state_method = :ssm_state
-
-  def after_initialize
-    self.ssm_state ||= 'open'
+  def teardown_db
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
   end
 
-  event :close, :open => :closed
-end
+  class Ticket < ActiveRecord::Base
+    extend SimpleStateMachine::ActiveRecord
 
-describe ActiveRecord do
+    state_machine_definition.state_method = :ssm_state
 
-  before do
-    setup_db
-  end
+    after_initialize :after_initialize
+    def after_initialize
+      self.ssm_state ||= 'open'
+    end
 
-  after do
-    teardown_db
+    event :close, :open => :closed
   end
 
-  it "has a default state" do
-    User.new.should be_new
-  end
+  describe ActiveRecord do
 
-  # TODO needs nesting/grouping, seems to have some duplication
+    before do
+      setup_db
+    end
 
-  describe "event_and_save" do
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
+    after do
+      teardown_db
     end
 
-    it "persist transitions even when state is attr_protected" do
-      user_class = Class.new(User)
-      user_class.instance_eval { attr_protected :state }
-      user = user_class.create!(:name => 'name', :state => 'x')
-      user.should be_new
-      user.invite_and_save
-      user.reload.should be_invited
+    it "has a default state" do
+      expect(User.new).to be_new
     end
 
     it "persists transitions when using send and a symbol" do
       user = User.create!(:name => 'name')
-      user.send(:invite_and_save).should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
+      expect(user.send(:invite_and_save)).to eq(true)
+      expect(User.find(user.id)).to be_invited
+      expect(User.find(user.id).activation_code).not_to be_nil
     end
 
-    it "raises an error if an invalid state_transition is called" do
-      user = User.create!(:name => 'name')
-      expect {
-        user.confirm_invitation_and_save 'abc'
-      }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
-                       "You cannot 'confirm_invitation' when state is 'new'")
-    end
+    # TODO needs nesting/grouping, seems to have some duplication
 
-    it "returns false and keeps state if record is invalid" do
-      user = User.new
-      user.should be_new
-      user.should_not be_valid
-      user.invite_and_save.should == false
-      user.should be_new
-    end
+    describe "event_and_save" do
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite_and_save).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
 
-    it "returns false, keeps state and keeps errors if event adds errors" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save!
-      user.should be_invited
-      user.confirm_invitation_and_save('x').should == false
-      user.should be_invited
-      user.errors.entries.should == [['activation_code', 'is invalid']]
-    end
+      it "persists transitions when using send and a symbol" do
+        user = User.create!(:name => 'name')
+        expect(user.send(:invite_and_save)).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
+
+      it "raises an error if an invalid state_transition is called" do
+        user = User.create!(:name => 'name')
+        expect {
+          user.confirm_invitation_and_save 'abc'
+        }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
+                         "You cannot 'confirm_invitation' when state is 'new'")
+      end
+
+      it "returns false and keeps state if record is invalid" do
+        user = User.new
+        expect(user).to be_new
+        expect(user).not_to be_valid
+        expect(user.invite_and_save).to eq(false)
+        expect(user).to be_new
+      end
+
+      it "returns false, keeps state and keeps errors if event adds errors" do
+        user = User.create!(:name => 'name')
+        user.invite_and_save!
+        expect(user).to be_invited
+        expect(user.confirm_invitation_and_save('x')).to eq(false)
+        expect(user).to be_invited
+        expect(Array(user.errors[:activation_code])).to eq(['is invalid'])
+      end
 
-    it "rollsback if an exception is raised" do
-      user_class = Class.new(User)
-      user_class.instance_eval do
-        define_method :invite_without_managed_state do
-          User.create!(:name => 'name2') #this shouldn't be persisted
-          User.create! #this should raise an error
+      it "rollsback if an exception is raised" do
+        user_class = Class.new(User)
+        user_class.instance_eval do
+          define_method :invite_without_managed_state do
+            User.create!(:name => 'name2') #this shouldn't be persisted
+            User.create! #this should raise an error
+          end
         end
+        expect(user_class.count).to eq(0)
+        user = user_class.create!(:name => 'name')
+        expect {
+          user.transaction { user.invite_and_save }
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Name can't be blank")
+        expect(user_class.count).to eq(1)
+        expect(user_class.first.name).to eq('name')
+        expect(user_class.first).to be_new
+      end
+
+      it "raises an error if an invalid state_transition is called" do
+        user = User.create!(:name => 'name')
+        expect {
+          user.confirm_invitation_and_save! 'abc'
+        }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
+                         "You cannot 'confirm_invitation' when state is 'new'")
       end
-      user_class.count.should == 0
-      user = user_class.create!(:name => 'name')
-      expect {
-        user.transaction { user.invite_and_save }
-      }.to raise_error(ActiveRecord::RecordInvalid,
-                       "Validation failed: Name can't be blank")
-      user_class.count.should == 1
-      user_class.first.name.should == 'name'
-      user_class.first.should be_new
     end
-  end
 
-  describe "event_and_save!" do
+    describe "event_and_save!" do
 
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save!.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
-    end
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite_and_save!).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
 
-    it "persist transitions even when state is attr_protected" do
-      user_class = Class.new(User)
-      user_class.instance_eval { attr_protected :state }
-      user = user_class.create!(:name => 'name', :state => 'x')
-      user.should be_new
-      user.invite_and_save!
-      user.reload.should be_invited
-    end
+      it "raises an error if an invalid state_transition is called" do
+        user = User.create!(:name => 'name')
+        expect {
+          user.confirm_invitation_and_save! 'abc'
+        }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
+                         "You cannot 'confirm_invitation' when state is 'new'")
+      end
 
-    it "raises an error if an invalid state_transition is called" do
-      user = User.create!(:name => 'name')
-      expect {
-        user.confirm_invitation_and_save! 'abc'
-      }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
-                       "You cannot 'confirm_invitation' when state is 'new'")
-    end
+      it "raises a RecordInvalid and keeps state if record is invalid" do
+        user = User.new
+        expect(user).to be_new
+        expect(user).not_to be_valid
+        expect {
+          user.invite_and_save!
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Name can't be blank")
+        expect(user).to be_new
+      end
 
-    it "raises a RecordInvalid and keeps state if record is invalid" do
-      user = User.new
-      user.should be_new
-      user.should_not be_valid
-      expect {
+      it "raises a RecordInvalid and keeps state if event adds errors" do
+        user = User.create!(:name => 'name')
         user.invite_and_save!
-      }.to raise_error(ActiveRecord::RecordInvalid,
-                       "Validation failed: Name can't be blank")
-      user.should be_new
-    end
-
-    it "raises a RecordInvalid and keeps state if event adds errors" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save!
-      user.should be_invited
-      expect {
-        user.confirm_invitation_and_save!('x')
-      }.to raise_error(ActiveRecord::RecordInvalid,
-                       "Validation failed: Activation code is invalid")
-      user.should be_invited
-    end
+        expect(user).to be_invited
+        expect {
+          user.confirm_invitation_and_save!('x')
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Activation code is invalid")
+        expect(user).to be_invited
+      end
 
-    it "rollsback if an exception is raised" do
-      user_class = Class.new(User)
-      user_class.instance_eval do
-        define_method :invite_without_managed_state do
-          User.create!(:name => 'name2') #this shouldn't be persisted
-          User.create! #this should raise an error
+      it "rollsback if an exception is raised" do
+        user_class = Class.new(User)
+        user_class.instance_eval do
+          define_method :invite_without_managed_state do
+            User.create!(:name => 'name2') #this shouldn't be persisted
+            User.create! #this should raise an error
+          end
         end
+        expect(user_class.count).to eq(0)
+        user = user_class.create!(:name => 'name')
+        expect {
+          user.transaction { user.invite_and_save! }
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Name can't be blank")
+        expect(user_class.count).to eq(1)
+        expect(user_class.first.name).to eq('name')
+        expect(user_class.first).to be_new
       end
-      user_class.count.should == 0
-      user = user_class.create!(:name => 'name')
-      expect {
-        user.transaction { user.invite_and_save! }
-      }.to raise_error(ActiveRecord::RecordInvalid,
-                       "Validation failed: Name can't be blank")
-      user_class.count.should == 1
-      user_class.first.name.should == 'name'
-      user_class.first.should be_new
+
     end
 
-  end
+    describe "event" do
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
 
-  describe "event" do
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
-    end
+      it "returns false, keeps state and keeps errors if event adds errors" do
+        user = User.create!(:name => 'name')
+        user.invite_and_save!
+        expect(user).to be_invited
+        expect(user.confirm_invitation('x')).to eq(false)
+        expect(user).to be_invited
+        expect(Array(user.errors[:activation_code])).to eq(['is invalid'])
+      end
 
-    it "returns false, keeps state and keeps errors if event adds errors" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save!
-      user.should be_invited
-      user.confirm_invitation('x').should == false
-      user.should be_invited
-      user.errors.entries.should == [['activation_code', 'is invalid']]
     end
 
-  end
+    describe "event!" do
 
-  describe "event!" do
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite!).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
 
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite!.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
-    end
+      it "raises a RecordInvalid and keeps state if record is invalid" do
+        user = User.new
+        expect(user).to be_new
+        expect(user).not_to be_valid
+        expect { user.invite! }.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Name can't be blank")
+        expect(user).to be_new
+      end
 
-    it "raises a RecordInvalid and keeps state if record is invalid" do
-      user = User.new
-      user.should be_new
-      user.should_not be_valid
-      expect { user.invite! }.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Name can't be blank")
-      user.should be_new
     end
 
-  end
+    describe 'custom state method' do
 
-  describe 'custom state method' do
+      it "persists transitions" do
+        ticket = Ticket.create!
+        expect(ticket.ssm_state).to eq('open')
+        expect(ticket.close!).to eq(true)
+        expect(ticket.ssm_state).to eq('closed')
+      end
 
-    it "persists transitions" do
-      ticket = Ticket.create!
-      ticket.ssm_state.should == 'open'
-      ticket.close!.should == true
-      ticket.ssm_state.should == 'closed'
-    end
+      it "persists transitions with !" do
+        ticket = Ticket.create!
+        expect(ticket.ssm_state).to eq('open')
+        ticket.close!
+        expect(ticket.ssm_state).to eq('closed')
+      end
 
-    it "persists transitions with !" do
-      ticket = Ticket.create!
-      ticket.ssm_state.should == 'open'
-      ticket.close!
-      ticket.ssm_state.should == 'closed'
     end
 
   end
-
 end
-

data/spec/decorator/default_spec.rb

@@ -10,7 +10,7 @@ describe SimpleStateMachine::Decorator::Default do
           @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
         end
       end
-      decorator = SimpleStateMachine::Decorator::Default.new klass
+      decorator = described_class.new klass
       decorator.decorate SimpleStateMachine::Transition.new(:event, :state1, :state2)
       @instance = klass.new
       @instance.state = 'state1'
@@ -18,26 +18,26 @@ describe SimpleStateMachine::Decorator::Default do
 
     describe "#initialize" do
       it "defines a state_machine method" do
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
       end
 
       it "defines a state getter method" do
-        @instance.should respond_to(:state)
+        expect(@instance).to respond_to(:state)
       end
 
       it "defines a state setter method" do
-        @instance.should respond_to(:state=)
+        expect(@instance).to respond_to(:state=)
       end
     end
 
     describe "#decorate" do
       it "defines state_helper_methods for both states" do
-        @instance.state1?.should  == true
-        @instance.state2?.should  == false
+        expect(@instance.state1?).to  eq(true)
+        expect(@instance.state2?).to  eq(false)
       end
 
       it "defines an event method" do
-        @instance.should respond_to(:event)
+        expect(@instance).to respond_to(:event)
       end
     end
   end
@@ -55,7 +55,7 @@ describe SimpleStateMachine::Decorator::Default do
         def event()   "predefined method" end
       end
       transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      decorator = SimpleStateMachine::Decorator::Default.new klass
+      decorator = described_class.new klass
       decorator.decorate transition
       klass.state_machine_definition.transitions << transition
       @instance = klass.new
@@ -64,26 +64,26 @@ describe SimpleStateMachine::Decorator::Default do
 
     describe "#initialize" do
       it "defines a state_machine method" do
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
       end
 
       it "defines a state getter method" do
-        @instance.should respond_to(:state)
+        expect(@instance).to respond_to(:state)
       end
 
       it "defines a state setter method" do
-        @instance.should respond_to(:state=)
+        expect(@instance).to respond_to(:state=)
       end
     end
 
     describe "#decorate" do
       it "does not overwrite predefined state_helper_methods" do
-        @instance.state1?.should  == "state1"
-        @instance.state2?.should  == "state2"
+        expect(@instance.state1?).to  eq("state1")
+        expect(@instance.state2?).to  eq("state2")
       end
 
       it "does not overwrite predefined event method" do
-        @instance.event.should == "predefined method"
+        expect(@instance.event).to eq("predefined method")
       end
     end
   end
@@ -102,7 +102,7 @@ describe SimpleStateMachine::Decorator::Default do
         def event()   "predefined method" end
       end
       transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      decorator = SimpleStateMachine::Decorator::Default.new klass
+      decorator = described_class.new klass
       decorator.decorate transition
       klass.state_machine_definition.transitions << transition
       @instance = klass.new
@@ -111,22 +111,22 @@ describe SimpleStateMachine::Decorator::Default do
 
     describe "#initialize" do
       it "defines a state_machine method" do
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
       end
 
       it "defines a state getter method" do
-        @instance.should respond_to(:state)
+        expect(@instance).to respond_to(:state)
       end
 
       it "defines a state setter method" do
-        @instance.should respond_to(:state=)
+        expect(@instance).to respond_to(:state=)
       end
     end
 
     describe "#decorate" do
       it "does not overwrite predefined protected state_helper_methods" do
-        @instance.send(:state1?).should  == "state1"
-        @instance.send(:state2?).should  == "state2"
+        expect(@instance.send(:state1?)).to  eq("state1")
+        expect(@instance.send(:state2?)).to  eq("state2")
       end
 
       it "keeps predefined protected state_helper_methods protected" do
@@ -135,7 +135,7 @@ describe SimpleStateMachine::Decorator::Default do
       end
 
       it "does not overwrite predefined protected event method" do
-        @instance.event.should == "predefined method"
+        expect(@instance.event).to eq("predefined method")
       end
     end
   end
@@ -154,7 +154,7 @@ describe SimpleStateMachine::Decorator::Default do
         def event()   "predefined method" end
       end
       transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      decorator = SimpleStateMachine::Decorator::Default.new klass
+      decorator = described_class.new klass
       decorator.decorate transition
       klass.state_machine_definition.transitions << transition
       @instance = klass.new
@@ -163,22 +163,22 @@ describe SimpleStateMachine::Decorator::Default do
 
     describe "#initialize" do
       it "defines a state_machine method" do
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
       end
 
       it "defines a state getter method" do
-        @instance.should respond_to(:state)
+        expect(@instance).to respond_to(:state)
       end
 
       it "defines a state setter method" do
-        @instance.should respond_to(:state=)
+        expect(@instance).to respond_to(:state=)
       end
     end
 
     describe "#decorate" do
       it "does not overwrite predefined private state_helper_methods" do
-        @instance.send(:state1?).should  == "state1"
-        @instance.send(:state2?).should  == "state2"
+        expect(@instance.send(:state1?)).to  eq("state1")
+        expect(@instance.send(:state2?)).to  eq("state2")
       end
 
       it "keeps predefined private state_helper_methods private" do
@@ -187,7 +187,7 @@ describe SimpleStateMachine::Decorator::Default do
       end
 
       it "does not overwrite predefined protected event method" do
-        @instance.event.should == "predefined method"
+        expect(@instance.event).to eq("predefined method")
       end
     end
   end