simple_state_machine 0.5.3 → 0.6.2

data/spec/active_record_spec.rb

@@ -1,223 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require "rubygems"
-require "bundler"
-Bundler.require
-#Bundler.setup(:test)#, :activerecord)
-require 'active_record'
-require 'examples/user'
-
-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
-    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'
-  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
-    User.new.should be_new
-  end
-
-  # TODO needs nesting/grouping, seems to have some duplication
-
-  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 "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 "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
-    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
-      user.should be_new
-      user.should_not be_valid
-      user.invite_and_save.should == false
-      user.should 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!
-      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
-
-  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
-    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 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_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
-
-  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!
-      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
-
-    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
-      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
-
-    it "persists transitions" do
-      ticket = Ticket.create!
-      ticket.should be_open
-      ticket.close!.should == true
-      ticket.should be_closed
-    end
-
-    it "persists transitions with !" do
-      ticket = Ticket.create!
-      ticket.should be_open
-      ticket.close!
-      ticket.should be_closed
-    end
-
-  end
-
-end
-

data/spec/decorator_spec.rb

@@ -1,195 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe SimpleStateMachine::Decorator 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 = SimpleStateMachine::Decorator.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
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        @instance.should respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        @instance.should 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
-      end
-      
-      it "defines an event method" do
-        @instance.should 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 = SimpleStateMachine::Decorator.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
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        @instance.should respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        @instance.should 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"
-      end
-
-      it "does not overwrite predefined event method" do
-        @instance.event.should == "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 = SimpleStateMachine::Decorator.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
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        @instance.should respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        @instance.should 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"
-      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
-        @instance.event.should == "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 = SimpleStateMachine::Decorator.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
-        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
-      end
-
-      it "defines a state getter method" do
-        @instance.should respond_to(:state)
-      end
-
-      it "defines a state setter method" do
-        @instance.should 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"
-      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
-        @instance.event.should == "predefined method"
-      end
-    end
-  end
-
-end

data/spec/examples_spec.rb

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

data/spec/mountable_spec.rb

@@ -1,24 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Mountable" do
-  before do
-    mountable_class = Class.new(SimpleStateMachine::StateMachineDefinition) do
-      def initialize(subject)
-        self.lazy_decorator = lambda { SimpleStateMachine::Decorator.new(subject) }
-        add_transition(:event, :state1, :state2)
-      end
-    end
-    klass = Class.new do
-      extend SimpleStateMachine::Mountable
-      self.state_machine_definition = mountable_class.new self
-    end
-    @instance = klass.new
-    @instance.state = 'state1'
-  end
-
-  it "has state_helper methods" do
-    @instance.should be_state1
-    @instance.should_not be_state2
-  end
-
-end

data/spec/simple_state_machine_spec.rb

@@ -1,129 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'cgi'
-
-describe SimpleStateMachine do
- 
-  it "has an error that extends RuntimeError" do
-    SimpleStateMachine::IllegalStateTransitionError.superclass.should == RuntimeError
-  end
-
-  describe ".event" do
-
-    before do
-      @klass = Class.new do
-        extend SimpleStateMachine
-        def initialize(state = 'state1')
-          @state = state
-        end
-      end
-    end
-
-    it "changes state if event has multiple transitions" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        event :event, :state1 => :state2, :state2 => :state3
-      end
-      example = klass.new
-      example.should be_state1
-      example.event
-      example.should be_state2
-      example.event
-      example.should be_state3
-    end
-
-    it "changes state if event has multiple froms" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        event :event, [:state1, :state2] => :state3
-      end
-      example = klass.new
-      example.event
-      example.should be_state3
-      example = klass.new 'state2'
-      example.should be_state2
-      example.event
-      example.should be_state3
-    end
-
-    it "changes state if event has all as from" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        event :other_event, :state1 => :state2
-        event :event, :all => :state3
-      end
-      example = klass.new
-      example.event
-      example.should be_state3
-      example = klass.new 'state2'
-      example.should be_state2
-      example.event
-      example.should be_state3
-    end
-
-    it "changes state when state is a symbol instead of a string" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        event :event, :state1 => :state2
-      end  
-      example = klass.new :state1
-      example.state.should == :state1
-      example.send(:event)
-      example.should be_state2
-    end
-
-    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
-      example = class_with_error.new
-      example.should be_state1
-      example.raise_error
-      example.should be_failed
-    end
-    
-    it "raises an error if an invalid state_transition is called" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        event :event,  :state1 => :state2
-        event :event2, :state2 => :state3
-      end  
-      example = klass.new
-      lambda { example.event2 }.should raise_error(SimpleStateMachine::IllegalStateTransitionError, "You cannot 'event2' when state is 'state1'")
-    end
-
-    it "returns what the decorated method returns" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        event :event1,  :state1 => :state2
-        define_method :event2 do
-          'event2'
-        end
-        event :event2, :state2 => :state3
-      end  
-      example = klass.new
-      example.event1.should == nil
-      example.event2.should == 'event2'
-    end
-
-    it "calls existing methods" do
-      klass = Class.new(@klass)
-      klass.instance_eval do
-        attr_accessor :event_called
-        define_method :event do
-          @event_called = true
-        end
-        event :event, :state1 => :state2
-      end  
-      example = klass.new
-      example.event
-      example.event_called.should == true
-    end
-
-  end
-
-end
-

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'simple_state_machine'
-require 'examples/conversation'
-require 'examples/lamp'
-require 'examples/traffic_light'
-