simple_state_machine 0.6.1 → 0.6.2

data/spec/active_record_spec.rb

@@ -1,250 +0,0 @@
-require 'spec_helper'
-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
-
-  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
-
-    after_initialize :after_initialize
-    def after_initialize
-      self.ssm_state ||= 'open'
-    end
-
-    event :close, :open => :closed
-  end
-
-  describe ActiveRecord do
-
-    before do
-      setup_db
-    end
-
-    after do
-      teardown_db
-    end
-
-    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')
-      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
-
-    # TODO needs nesting/grouping, seems to have some duplication
-
-    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 "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
-          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
-    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 "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 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 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
-          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
-
-    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
-
-      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
-
-    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
-
-      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
-
-    end
-
-    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 with !" do
-        ticket = Ticket.create!
-        expect(ticket.ssm_state).to eq('open')
-        ticket.close!
-        expect(ticket.ssm_state).to eq('closed')
-      end
-
-    end
-
-  end
-end

data/spec/decorator/default_spec.rb

@@ -1,195 +0,0 @@
-require 'spec_helper'
-
-describe SimpleStateMachine::Decorator::Default do
-
-  context "given a class" do
-    before do
-      klass = Class.new do
-        # TODO remove the need for defining this method
-        def self.state_machine_definition
-          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
-        end
-      end
-      decorator = described_class.new klass
-      decorator.decorate SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      @instance = klass.new
-      @instance.state = 'state1'
-    end
-
-    describe "#initialize" do
-      it "defines a state_machine method" do
-        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        expect(@instance).to respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        expect(@instance).to respond_to(:state=)
-      end
-    end
-
-    describe "#decorate" do
-      it "defines state_helper_methods for both states" do
-        expect(@instance.state1?).to  eq(true)
-        expect(@instance.state2?).to  eq(false)
-      end
-
-      it "defines an event method" do
-        expect(@instance).to respond_to(:event)
-      end
-    end
-  end
-
-  context "given a class with predefined public methods" do
-    before do
-      klass = Class.new do
-        # TODO remove the need for defining this method
-        def self.state_machine_definition
-          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
-        end
-        # predefined methods
-        def state1?() "state1"            end
-        def state2?() "state2"            end
-        def event()   "predefined method" end
-      end
-      transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      decorator = described_class.new klass
-      decorator.decorate transition
-      klass.state_machine_definition.transitions << transition
-      @instance = klass.new
-      @instance.state = 'state1'
-    end
-
-    describe "#initialize" do
-      it "defines a state_machine method" do
-        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        expect(@instance).to respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        expect(@instance).to respond_to(:state=)
-      end
-    end
-
-    describe "#decorate" do
-      it "does not overwrite predefined state_helper_methods" do
-        expect(@instance.state1?).to  eq("state1")
-        expect(@instance.state2?).to  eq("state2")
-      end
-
-      it "does not overwrite predefined event method" do
-        expect(@instance.event).to eq("predefined method")
-      end
-    end
-  end
-
-  context "given a class with predefined protected methods" do
-    before do
-      klass = Class.new do
-        # TODO remove the need for defining this method
-        def self.state_machine_definition
-          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
-        end
-        # predefined methods
-        protected
-        def state1?() "state1"            end
-        def state2?() "state2"            end
-        def event()   "predefined method" end
-      end
-      transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      decorator = described_class.new klass
-      decorator.decorate transition
-      klass.state_machine_definition.transitions << transition
-      @instance = klass.new
-      @instance.state = 'state1'
-    end
-
-    describe "#initialize" do
-      it "defines a state_machine method" do
-        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        expect(@instance).to respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        expect(@instance).to respond_to(:state=)
-      end
-    end
-
-    describe "#decorate" do
-      it "does not overwrite predefined protected state_helper_methods" do
-        expect(@instance.send(:state1?)).to  eq("state1")
-        expect(@instance.send(:state2?)).to  eq("state2")
-      end
-
-      it "keeps predefined protected state_helper_methods protected" do
-        expect { @instance.state1? }.to raise_error(NoMethodError)
-        expect { @instance.state2? }.to raise_error(NoMethodError)
-      end
-
-      it "does not overwrite predefined protected event method" do
-        expect(@instance.event).to eq("predefined method")
-      end
-    end
-  end
-
-  context "given a class with predefined private methods" do
-    before do
-      klass = Class.new do
-        # TODO the need for defining this method
-        def self.state_machine_definition
-          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
-        end
-        # predefined methods
-        private
-        def state1?() "state1"            end
-        def state2?() "state2"            end
-        def event()   "predefined method" end
-      end
-      transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
-      decorator = described_class.new klass
-      decorator.decorate transition
-      klass.state_machine_definition.transitions << transition
-      @instance = klass.new
-      @instance.state = 'state1'
-    end
-
-    describe "#initialize" do
-      it "defines a state_machine method" do
-        expect(@instance.state_machine).to be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        expect(@instance).to respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        expect(@instance).to respond_to(:state=)
-      end
-    end
-
-    describe "#decorate" do
-      it "does not overwrite predefined private state_helper_methods" do
-        expect(@instance.send(:state1?)).to  eq("state1")
-        expect(@instance.send(:state2?)).to  eq("state2")
-      end
-
-      it "keeps predefined private state_helper_methods private" do
-        expect { @instance.state1? }.to raise_error(NoMethodError)
-        expect { @instance.state2? }.to raise_error(NoMethodError)
-      end
-
-      it "does not overwrite predefined protected event method" do
-        expect(@instance.event).to eq("predefined method")
-      end
-    end
-  end
-
-end

data/spec/examples_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe "Examples" do
-  describe "TrafficLight" do
-    it "changes to the next state" do
-      tl = TrafficLight.new
-      expect(tl).to be_green
-      tl.change_state
-      expect(tl).to be_orange
-      tl.change_state
-      expect(tl).to be_red
-      tl.change_state
-      expect(tl).to be_green
-    end
-  end
-
-  describe "Lamp" do
-    it "changes between :on and :off" do
-      lamp = Lamp.new
-      expect(lamp).to be_off
-      lamp.push_button1
-      expect(lamp).to be_on
-      lamp.push_button2
-      expect(lamp).to be_off
-      lamp.push_button2
-      expect(lamp).to be_on
-      lamp.push_button1
-      expect(lamp).to be_off
-    end
-  end
-
-  describe "Conversation" do
-    it "is :unread by default" do
-      conversation = Conversation.new
-      expect(conversation).to be_unread
-    end
-
-    it "changes to read on view" do
-      conversation = Conversation.new
-      conversation.view
-      expect(conversation).to be_read
-    end
-
-    it "changes to closed on close" do
-      conversation = Conversation.new
-      conversation.close
-      expect(conversation).to be_closed
-    end
-
-    it "changes to closed on close if :read" do
-      conversation = Conversation.new
-      conversation.view
-      conversation.close
-      expect(conversation).to be_closed
-    end
-
-  end
-
-end
-

data/spec/mountable_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe SimpleStateMachine::Mountable do
-  class MountableExample < SimpleStateMachine::StateMachineDefinition
-    event(:event, :state1 => :state2)
-
-    def decorator_class
-      SimpleStateMachine::Decorator::Default
-    end
-  end
-
-  let(:klass) do
-    Class.new do
-      attr_accessor :event_called
-      extend SimpleStateMachine::Mountable
-      mount_state_machine MountableExample
-      def event_without_managed_state
-        @event_called = true
-      end
-    end
-  end
-  subject do
-    klass.new.tap{|i| i.state = 'state1' }
-  end
-
-  it "has state_helper methods" do
-    expect(subject).to be_state1
-    expect(subject).not_to be_state2
-  end
-
-  it "calls existing methods" do
-    subject.event
-    expect(subject).to be_state2
-    expect(subject.event_called).to eq(true)
-  end
-end

data/spec/simple_state_machine_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-describe SimpleStateMachine do
-
-  it "has an error that extends RuntimeError" do
-    expect(SimpleStateMachine::IllegalStateTransitionError.superclass).to eq(RuntimeError)
-  end
-
-  let(:klass) do
-    Class.new do
-      extend SimpleStateMachine
-      def initialize(state = 'state1')
-        @state = state
-      end
-    end
-  end
-
-  describe ".event" do
-
-    it "returns what the decorated method returns" do
-      klass.instance_eval do
-        event :event1,  :state1 => :state2
-        define_method :event2 do
-          'event2'
-        end
-        event :event2, :state2 => :state3
-      end
-      subject = klass.new
-      expect(subject.event1).to eq(nil)
-      expect(subject.event2).to eq('event2')
-    end
-
-    it "calls existing methods" do
-      klass.instance_eval do
-        attr_accessor :event_called
-        define_method :event do
-          @event_called = true
-        end
-        event :event, :state1 => :state2
-      end
-      subject = klass.new
-      subject.event
-      expect(subject.event_called).to eq(true)
-    end
-
-    context "given an event has multiple transitions" do
-      before do
-        klass.instance_eval do
-          event :event, :state1 => :state2, :state2 => :state3
-        end
-      end
-
-      it "changes state for all transitions" do
-        subject = klass.new
-        expect(subject).to be_state1
-        subject.event
-        expect(subject).to be_state2
-        subject.event
-        expect(subject).to be_state3
-      end
-    end
-
-    context "given an event has multiple from states" do
-      before do
-        klass.instance_eval do
-          event :event, [:state1, :state2] => :state3
-        end
-      end
-
-      it "changes state for all from states" do
-        subject = klass.new
-        subject.event
-        expect(subject).to be_state3
-        subject = klass.new 'state2'
-        expect(subject).to be_state2
-        subject.event
-        expect(subject).to be_state3
-      end
-    end
-
-    context "given an event has :all as from state" do
-      before do
-        klass.instance_eval do
-          event :other_event, :state1 => :state2
-          event :event, :all => :state3
-        end
-      end
-
-      it "changes state from all states" do
-        subject = klass.new
-        subject.event
-        expect(subject).to be_state3
-        subject = klass.new 'state2'
-        expect(subject).to be_state2
-        subject.event
-        expect(subject).to be_state3
-      end
-    end
-
-    context "given state is a symbol instead of a string" do
-      before do
-        klass.instance_eval do
-          event :event, :state1 => :state2
-        end
-      end
-
-      it "changes state" do
-        subject = klass.new :state1
-        expect(subject.state).to eq(:state1)
-        subject.send(:event)
-        expect(subject).to be_state2
-      end
-    end
-
-    context "given an RuntimeError begin state" do
-      it "changes state to error_state when error can be caught" do
-        class_with_error = Class.new(klass)
-        class_with_error.instance_eval do
-          define_method :raise_error do
-            raise RuntimeError.new
-          end
-          event :raise_error, :state1 => :state2, RuntimeError => :failed
-        end
-        subject = class_with_error.new
-        expect(subject).to be_state1
-        subject.raise_error
-        expect(subject).to be_failed
-      end
-
-      it "changes state to error_state when error superclass can be caught" do
-        error_subclass   = Class.new(RuntimeError)
-        class_with_error = Class.new(klass)
-        class_with_error.instance_eval do
-          define_method :raise_error do
-            raise error_subclass.new
-          end
-          event :raise_error, :state1 => :state2, RuntimeError => :failed
-        end
-        subject = class_with_error.new
-        expect(subject).to be_state1
-        subject.raise_error
-        expect(subject).to be_failed
-      end
-    end
-
-    context "given an invalid state_transition is called" do
-      before do
-        klass.instance_eval do
-          event :event,  :state1 => :state2
-          event :event2, :state2 => :state3
-        end
-      end
-
-      it "raises an IllegalStateTransitionError" do
-        subject = klass.new
-        expect { subject.event2 }.to raise_error(
-            SimpleStateMachine::IllegalStateTransitionError,
-            "You cannot 'event2' when state is 'state1'")
-      end
-    end
-
-  end
-
-end
-