state_machines 0.0.2 → 0.1.0

data/spec/state_machines/state_context_spec.rb

@@ -1,442 +0,0 @@
-require 'spec_helper'
-
-class Validateable
-  class << self
-    def validate(*args, &block)
-      args << block if block_given?
-      args
-    end
-  end
-end
-describe StateMachines::StateContext do
-  context '' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      @machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      @state = @machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(@state)
-    end
-
-    it 'should_have_a_machine' do
-      assert_equal @machine, @state_context.machine
-    end
-
-    it 'should_have_a_state' do
-      assert_equal @state, @state_context.state
-    end
-  end
-
-  context 'Transition' do
-    before(:each) do
-      @klass = Class.new
-      @machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      @state = @machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(@state)
-    end
-
-    it 'should_not_allow_except_to' do
-      assert_raise(ArgumentError) { @state_context.transition(:except_to => :idling) }
-      # assert_equal 'Invalid key(s): except_to', exception.message
-    end
-
-    it 'should_not_allow_except_from' do
-      assert_raise(ArgumentError) { @state_context.transition(:except_from => :idling) }
-      #assert_equal 'Invalid key(s): except_from', exception.message
-    end
-
-    it 'should_not_allow_implicit_transitions' do
-      assert_raise(ArgumentError) { @state_context.transition(:parked => :idling) }
-      #assert_equal 'Invalid key(s): parked', exception.message
-    end
-
-    it 'should_not_allow_except_on' do
-      assert_raise(ArgumentError) { @state_context.transition(:except_on => :park) }
-      #assert_equal 'Invalid key(s): except_on', exception.message
-    end
-
-    it 'should_require_on_event' do
-      assert_raise(ArgumentError) { @state_context.transition(:to => :idling) }
-      #assert_equal 'Must specify :on event', exception.message
-    end
-
-    it 'should_not_allow_missing_from_and_to' do
-      assert_raise(ArgumentError) { @state_context.transition(:on => :ignite) }
-      #assert_equal 'Must specify either :to or :from state', exception.message
-    end
-
-    it 'should_not_allow_from_and_to' do
-      assert_raise(ArgumentError) { @state_context.transition(:on => :ignite, :from => :parked, :to => :idling) }
-      #assert_equal 'Must specify either :to or :from state', exception.message
-    end
-
-    it 'should_allow_to_state_if_missing_from_state' do
-      assert_nothing_raised { @state_context.transition(:on => :park, :from => :parked) }
-    end
-
-    it 'should_allow_from_state_if_missing_to_state' do
-      assert_nothing_raised { @state_context.transition(:on => :ignite, :to => :idling) }
-    end
-
-    it 'should_automatically_set_to_option_with_from_state' do
-      branch = @state_context.transition(:from => :idling, :on => :park)
-      assert_instance_of StateMachines::Branch, branch
-
-      state_requirements = branch.state_requirements
-      assert_equal 1, state_requirements.length
-
-      from_requirement = state_requirements[0][:to]
-      assert_instance_of StateMachines::WhitelistMatcher, from_requirement
-      assert_equal [:parked], from_requirement.values
-    end
-
-    it 'should_automatically_set_from_option_with_to_state' do
-      branch = @state_context.transition(:to => :idling, :on => :ignite)
-      assert_instance_of StateMachines::Branch, branch
-
-      state_requirements = branch.state_requirements
-      assert_equal 1, state_requirements.length
-
-      from_requirement = state_requirements[0][:from]
-      assert_instance_of StateMachines::WhitelistMatcher, from_requirement
-      assert_equal [:parked], from_requirement.values
-    end
-
-    it 'should_allow_if_condition' do
-      assert_nothing_raised { @state_context.transition(:to => :idling, :on => :park, :if => :seatbelt_on?) }
-    end
-
-    it 'should_allow_unless_condition' do
-      assert_nothing_raised { @state_context.transition(:to => :idling, :on => :park, :unless => :seatbelt_off?) }
-    end
-
-    it 'should_include_all_transition_states_in_machine_states' do
-      @state_context.transition(:to => :idling, :on => :ignite)
-
-      assert_equal [:parked, :idling], @machine.states.map { |state| state.name }
-    end
-
-    it 'should_include_all_transition_events_in_machine_events' do
-      @state_context.transition(:to => :idling, :on => :ignite)
-
-      assert_equal [:ignite], @machine.events.map { |event| event.name }
-    end
-
-    it 'should_allow_multiple_events' do
-      @state_context.transition(:to => :idling, :on => [:ignite, :shift_up])
-
-      assert_equal [:ignite, :shift_up], @machine.events.map { |event| event.name }
-    end
-  end
-
-  context 'WithMatchingTransition' do
-    before(:each) do
-      @klass = Class.new
-      @machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      @state = @machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(@state)
-      @state_context.transition(:to => :idling, :on => :ignite)
-
-      @event = @machine.event(:ignite)
-      @object = @klass.new
-    end
-
-    it 'should_be_able_to_fire' do
-      assert @event.can_fire?(@object)
-    end
-
-    it 'should_have_a_transition' do
-      transition = @event.transition_for(@object)
-      assert_not_nil transition
-      assert_equal 'parked', transition.from
-      assert_equal 'idling', transition.to
-      assert_equal :ignite, transition.event
-    end
-  end
-
-  context 'Proxy' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-    end
-
-    it 'should_call_class_with_same_arguments' do
-      options = {}
-      validation = @state_context.validate(:name, options)
-
-      assert_equal [:name, options], validation
-    end
-
-    it 'should_pass_block_through_to_class' do
-      options = {}
-      proxy_block = lambda {}
-      validation = @state_context.validate(:name, options, &proxy_block)
-
-      assert_equal [:name, options, proxy_block], validation
-    end
-  end
-
-  context 'ProxyWithoutConditions' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-      @object = @klass.new
-
-      @options = @state_context.validate[0]
-    end
-
-    it 'should_have_options_configuration' do
-      assert_instance_of Hash, @options
-    end
-
-    it 'should_have_if_option' do
-      assert_not_nil @options[:if]
-    end
-
-    it 'should_be_false_if_state_is_different' do
-      @object.state = nil
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_true_if_state_matches' do
-      assert @options[:if].call(@object)
-    end
-  end
-
-  context 'ProxyWithIfCondition' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-      @object = @klass.new
-
-      @condition_result = nil
-      @options = @state_context.validate(:if => lambda { @condition_result })[0]
-    end
-
-    it 'should_have_if_option' do
-      assert_not_nil @options[:if]
-    end
-
-    it 'should_be_false_if_state_is_different' do
-      @object.state = nil
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_false_if_original_condition_is_false' do
-      @condition_result = false
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_true_if_state_matches_and_original_condition_is_true' do
-      @condition_result = true
-      assert @options[:if].call(@object)
-    end
-
-    it 'should_evaluate_symbol_condition' do
-      @klass.class_eval do
-        attr_accessor :callback
-      end
-
-      options = @state_context.validate(:if => :callback)[0]
-
-      object = @klass.new
-      object.callback = false
-      assert !options[:if].call(object)
-
-      object.callback = true
-      assert options[:if].call(object)
-    end
-
-    it 'should_evaluate_string_condition' do
-      @klass.class_eval do
-        attr_accessor :callback
-      end
-
-      options = @state_context.validate(:if => '@callback')[0]
-
-      object = @klass.new
-      object.callback = false
-      assert !options[:if].call(object)
-
-      object.callback = true
-      assert options[:if].call(object)
-    end
-  end
-
-  context 'ProxyWithMultipleIfConditions' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-      @object = @klass.new
-
-      @first_condition_result = nil
-      @second_condition_result = nil
-      @options = @state_context.validate(:if => [lambda { @first_condition_result }, lambda { @second_condition_result }])[0]
-    end
-
-    it 'should_be_true_if_all_conditions_are_true' do
-      @first_condition_result = true
-      @second_condition_result = true
-      assert @options[:if].call(@object)
-    end
-
-    it 'should_be_false_if_any_condition_is_false' do
-      @first_condition_result = true
-      @second_condition_result = false
-      assert !@options[:if].call(@object)
-
-      @first_condition_result = false
-      @second_condition_result = true
-      assert !@options[:if].call(@object)
-    end
-  end
-
-  context 'ProxyWithUnlessCondition' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-      @object = @klass.new
-
-      @condition_result = nil
-      @options = @state_context.validate(:unless => lambda { @condition_result })[0]
-    end
-
-    it 'should_have_if_option' do
-      assert_not_nil @options[:if]
-    end
-
-    it 'should_be_false_if_state_is_different' do
-      @object.state = nil
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_false_if_original_condition_is_true' do
-      @condition_result = true
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_true_if_state_matches_and_original_condition_is_false' do
-      @condition_result = false
-      assert @options[:if].call(@object)
-    end
-
-    it 'should_evaluate_symbol_condition' do
-      @klass.class_eval do
-        attr_accessor :callback
-      end
-
-      options = @state_context.validate(:unless => :callback)[0]
-
-      object = @klass.new
-      object.callback = true
-      assert !options[:if].call(object)
-
-      object.callback = false
-      assert options[:if].call(object)
-    end
-
-    it 'should_evaluate_string_condition' do
-      @klass.class_eval do
-        attr_accessor :callback
-      end
-
-      options = @state_context.validate(:unless => '@callback')[0]
-
-      object = @klass.new
-      object.callback = true
-      assert !options[:if].call(object)
-
-      object.callback = false
-      assert options[:if].call(object)
-    end
-  end
-
-  context 'ProxyWithMultipleUnlessConditions' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-      @object = @klass.new
-
-      @first_condition_result = nil
-      @second_condition_result = nil
-      @options = @state_context.validate(:unless => [lambda { @first_condition_result }, lambda { @second_condition_result }])[0]
-    end
-
-    it 'should_be_true_if_all_conditions_are_false' do
-      @first_condition_result = false
-      @second_condition_result = false
-      assert @options[:if].call(@object)
-    end
-
-    it 'should_be_false_if_any_condition_is_true' do
-      @first_condition_result = true
-      @second_condition_result = false
-      assert !@options[:if].call(@object)
-
-      @first_condition_result = false
-      @second_condition_result = true
-      assert !@options[:if].call(@object)
-    end
-  end
-
-  context 'ProxyWithIfAndUnlessConditions' do
-    before(:each) do
-      @klass = Class.new(Validateable)
-      machine = StateMachines::Machine.new(@klass, :initial => :parked)
-      state = machine.state :parked
-
-      @state_context = StateMachines::StateContext.new(state)
-      @object = @klass.new
-
-      @if_condition_result = nil
-      @unless_condition_result = nil
-      @options = @state_context.validate(:if => lambda { @if_condition_result }, :unless => lambda { @unless_condition_result })[0]
-    end
-
-    it 'should_be_false_if_if_condition_is_false' do
-      @if_condition_result = false
-      @unless_condition_result = false
-      assert !@options[:if].call(@object)
-
-      @if_condition_result = false
-      @unless_condition_result = true
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_false_if_unless_condition_is_true' do
-      @if_condition_result = false
-      @unless_condition_result = true
-      assert !@options[:if].call(@object)
-
-      @if_condition_result = true
-      @unless_condition_result = true
-      assert !@options[:if].call(@object)
-    end
-
-    it 'should_be_true_if_if_condition_is_true_and_unless_condition_is_false' do
-      @if_condition_result = true
-      @unless_condition_result = false
-      assert @options[:if].call(@object)
-    end
-  end
-end

data/spec/state_machines/state_machine_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-describe 'StateMachines' do
-  context 'ByDefault' do
-    before(:each) do
-      @klass = Class.new
-      @machine = @klass.state_machine
-    end
-
-    it 'should_use_state_attribute' do
-      assert_equal :state, @machine.attribute
-    end
-  end
-
-  context '' do
-    let(:klass) { Class.new }
-
-    it 'should_allow_state_machines_on_any_class' do
-      expect(klass.respond_to?(:state_machine)).to be_truthy
-    end
-
-    it 'should_evaluate_block_within_machine_context' do
-      responded = false
-      klass.state_machine(:state) do
-        responded = respond_to?(:event)
-      end
-      expect(responded).to be_truthy
-    end
-  end
-end