state_machines 0.5.0 → 0.10.0

data/test/unit/branch/branch_with_conflicting_from_requirements_test.rb

@@ -1,8 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithConflictingFromRequirementsTest < StateMachinesTest
-  def test_should_raise_an_exception
-    exception = assert_raises(ArgumentError) { StateMachines::Branch.new(from: :parked, except_from: :parked) }
-    assert_equal 'Conflicting keys: from, except_from', exception.message
-  end
-end

data/test/unit/branch/branch_with_conflicting_on_requirements_test.rb

@@ -1,8 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithConflictingOnRequirementsTest < StateMachinesTest
-  def test_should_raise_an_exception
-    exception = assert_raises(ArgumentError) { StateMachines::Branch.new(on: :ignite, except_on: :ignite) }
-    assert_equal 'Conflicting keys: on, except_on', exception.message
-  end
-end

data/test/unit/branch/branch_with_conflicting_to_requirements_test.rb

@@ -1,8 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithConflictingToRequirementsTest < StateMachinesTest
-  def test_should_raise_an_exception
-    exception = assert_raises(ArgumentError) { StateMachines::Branch.new(to: :idling, except_to: :idling) }
-    assert_equal 'Conflicting keys: to, except_to', exception.message
-  end
-end

data/test/unit/branch/branch_with_different_requirements_test.rb

@@ -1,41 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithDifferentRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(from: :parked, to: :idling, on: :ignite)
-  end
-
-  def test_should_match_empty_query
-    assert @branch.matches?(@object)
-  end
-
-  def test_should_match_if_all_requirements_match
-    assert @branch.matches?(@object, from: :parked, to: :idling, on: :ignite)
-  end
-
-  def test_should_not_match_if_from_not_included
-    refute @branch.matches?(@object, from: :idling)
-  end
-
-  def test_should_not_match_if_to_not_included
-    refute @branch.matches?(@object, to: :parked)
-  end
-
-  def test_should_not_match_if_on_not_included
-    refute @branch.matches?(@object, on: :park)
-  end
-
-  def test_should_be_nil_if_unmatched
-    assert_nil @branch.match(@object, from: :parked, to: :idling, on: :park)
-  end
-
-  def test_should_include_all_known_states
-    assert_equal [:parked, :idling], @branch.known_states
-  end
-
-  def test_should_not_duplicate_known_statse
-    branch = StateMachines::Branch.new(except_from: :idling, to: :idling, on: :ignite)
-    assert_equal [:idling], branch.known_states
-  end
-end

data/test/unit/branch/branch_with_except_from_matcher_requirement_test.rb

@@ -1,8 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithExceptFromMatcherRequirementTest < StateMachinesTest
-  def test_should_raise_an_exception
-    exception = assert_raises(ArgumentError) { StateMachines::Branch.new(except_from: StateMachines::AllMatcher.instance) }
-    assert_equal ':except_from option cannot use matchers; use :from instead', exception.message
-  end
-end

data/test/unit/branch/branch_with_except_from_requirement_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithExceptFromRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(except_from: :parked)
-  end
-
-  def test_should_use_a_blacklist_matcher
-    assert_instance_of StateMachines::BlacklistMatcher, @branch.state_requirements.first[:from]
-  end
-
-  def test_should_match_if_not_included
-    assert @branch.matches?(@object, from: :idling)
-  end
-
-  def test_should_not_match_if_included
-    refute @branch.matches?(@object, from: :parked)
-  end
-
-  def test_should_match_if_nil
-    assert @branch.matches?(@object, from: nil)
-  end
-
-  def test_should_ignore_to
-    assert @branch.matches?(@object, from: :idling, to: :parked)
-  end
-
-  def test_should_ignore_on
-    assert @branch.matches?(@object, from: :idling, on: :ignite)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_except_on_matcher_requirement_test.rb

@@ -1,8 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithExceptOnMatcherRequirementTest < StateMachinesTest
-  def test_should_raise_an_exception
-    exception = assert_raises(ArgumentError) { StateMachines::Branch.new(except_on: StateMachines::AllMatcher.instance) }
-    assert_equal ':except_on option cannot use matchers; use :on instead', exception.message
-  end
-end

data/test/unit/branch/branch_with_except_on_requirement_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithExceptOnRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(except_on: :ignite)
-  end
-
-  def test_should_use_a_blacklist_matcher
-    assert_instance_of StateMachines::BlacklistMatcher, @branch.event_requirement
-  end
-
-  def test_should_match_if_not_included
-    assert @branch.matches?(@object, on: :park)
-  end
-
-  def test_should_not_match_if_included
-    refute @branch.matches?(@object, on: :ignite)
-  end
-
-  def test_should_match_if_nil
-    assert @branch.matches?(@object, on: nil)
-  end
-
-  def test_should_ignore_to
-    assert @branch.matches?(@object, on: :park, to: :idling)
-  end
-
-  def test_should_ignore_from
-    assert @branch.matches?(@object, on: :park, from: :parked)
-  end
-
-  def test_should_not_be_included_in_known_states
-    assert_equal [], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_except_to_matcher_requirement_test.rb

@@ -1,8 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithExceptToMatcherRequirementTest < StateMachinesTest
-  def test_should_raise_an_exception
-    exception = assert_raises(ArgumentError) { StateMachines::Branch.new(except_to: StateMachines::AllMatcher.instance) }
-    assert_equal ':except_to option cannot use matchers; use :to instead', exception.message
-  end
-end

data/test/unit/branch/branch_with_except_to_requirement_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithExceptToRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(except_to: :idling)
-  end
-
-  def test_should_use_a_blacklist_matcher
-    assert_instance_of StateMachines::BlacklistMatcher, @branch.state_requirements.first[:to]
-  end
-
-  def test_should_match_if_not_included
-    assert @branch.matches?(@object, to: :parked)
-  end
-
-  def test_should_not_match_if_included
-    refute @branch.matches?(@object, to: :idling)
-  end
-
-  def test_should_match_if_nil
-    assert @branch.matches?(@object, to: nil)
-  end
-
-  def test_should_ignore_from
-    assert @branch.matches?(@object, to: :parked, from: :idling)
-  end
-
-  def test_should_ignore_on
-    assert @branch.matches?(@object, to: :parked, on: :ignite)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:idling], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_from_matcher_requirement_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithFromMatcherRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(from: StateMachines::BlacklistMatcher.new([:idling, :parked]))
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, from: :first_gear)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, from: :idling)
-  end
-
-  def test_include_values_in_known_states
-    assert_equal [:idling, :parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_from_requirement_test.rb

@@ -1,45 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithFromRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(from: :parked)
-  end
-
-  def test_should_use_a_whitelist_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.state_requirements.first[:from]
-  end
-
-  def test_should_match_if_not_specified
-    assert @branch.matches?(@object, to: :idling)
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, from: :parked)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, from: :idling)
-  end
-
-  def test_should_not_match_if_nil
-    refute @branch.matches?(@object, from: nil)
-  end
-
-  def test_should_ignore_to
-    assert @branch.matches?(@object, from: :parked, to: :idling)
-  end
-
-  def test_should_ignore_on
-    assert @branch.matches?(@object, from: :parked, on: :ignite)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:parked], @branch.known_states
-  end
-
-  def test_should_include_requirement_in_match
-    match = @branch.match(@object, from: :parked)
-    assert_equal @branch.state_requirements.first[:from], match[:from]
-  end
-end

data/test/unit/branch/branch_with_if_conditional_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithIfConditionalTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_have_an_if_condition
-    branch = StateMachines::Branch.new(if: lambda { true })
-    refute_nil branch.if_condition
-  end
-
-  def test_should_match_if_true
-    branch = StateMachines::Branch.new(if: lambda { true })
-    assert branch.matches?(@object)
-  end
-
-  def test_should_not_match_if_false
-    branch = StateMachines::Branch.new(if: lambda { false })
-    refute branch.matches?(@object)
-  end
-
-  def test_should_be_nil_if_unmatched
-    branch = StateMachines::Branch.new(if: lambda { false })
-    assert_nil branch.match(@object)
-  end
-end

data/test/unit/branch/branch_with_implicit_and_explicit_requirements_test.rb

@@ -1,23 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithImplicitAndExplicitRequirementsTest < StateMachinesTest
-  def setup
-    @branch = StateMachines::Branch.new(parked: :idling, from: :parked)
-  end
-
-  def test_should_create_multiple_requirements
-    assert_equal 2, @branch.state_requirements.length
-  end
-
-  def test_should_create_implicit_requirements_for_implicit_options
-    assert(@branch.state_requirements.any? do |state_requirement|
-             state_requirement[:from].values == [:parked] && state_requirement[:to].values == [:idling]
-           end)
-  end
-
-  def test_should_create_implicit_requirements_for_explicit_options
-    assert(@branch.state_requirements.any? do |state_requirement|
-             state_requirement[:from].values == [:from] && state_requirement[:to].values == [:parked]
-           end)
-  end
-end

data/test/unit/branch/branch_with_implicit_from_requirement_matcher_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleFromRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(from: [:idling, :parked])
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, from: :idling)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, from: :first_gear)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:idling, :parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_implicit_requirement_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithImplicitRequirementTest < StateMachinesTest
-  def setup
-    @branch = StateMachines::Branch.new(parked: :idling, on: :ignite)
-  end
-
-  def test_should_create_an_event_requirement
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.event_requirement
-    assert_equal [:ignite], @branch.event_requirement.values
-  end
-
-  def test_should_use_a_whitelist_from_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.state_requirements.first[:from]
-  end
-
-  def test_should_use_a_whitelist_to_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.state_requirements.first[:to]
-  end
-end

data/test/unit/branch/branch_with_implicit_to_requirement_matcher_test.rb

@@ -1,16 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithImplicitToRequirementMatcherTest < StateMachinesTest
-  def setup
-    @matcher = StateMachines::BlacklistMatcher.new(:idling)
-    @branch = StateMachines::Branch.new(parked: @matcher)
-  end
-
-  def test_should_convert_from_to_whitelist_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.state_requirements.first[:from]
-  end
-
-  def test_should_not_convert_to_to_whitelist_matcher
-    assert_equal @matcher, @branch.state_requirements.first[:to]
-  end
-end

data/test/unit/branch/branch_with_multiple_except_from_requirements_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleExceptFromRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(except_from: [:idling, :parked])
-  end
-
-  def test_should_match_if_not_included
-    assert @branch.matches?(@object, from: :first_gear)
-  end
-
-  def test_should_not_match_if_included
-    refute @branch.matches?(@object, from: :idling)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:idling, :parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_multiple_except_on_requirements_test.rb

@@ -1,16 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleExceptOnRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(except_on: [:ignite, :park])
-  end
-
-  def test_should_match_if_not_included
-    assert @branch.matches?(@object, on: :shift_up)
-  end
-
-  def test_should_not_match_if_included
-    refute @branch.matches?(@object, on: :ignite)
-  end
-end

data/test/unit/branch/branch_with_multiple_except_to_requirements_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleExceptToRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(except_to: [:idling, :parked])
-  end
-
-  def test_should_match_if_not_included
-    assert @branch.matches?(@object, to: :first_gear)
-  end
-
-  def test_should_not_match_if_included
-    refute @branch.matches?(@object, to: :idling)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:idling, :parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_multiple_from_requirements_test.rb

@@ -1,16 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithImplicitFromRequirementMatcherTest < StateMachinesTest
-  def setup
-    @matcher = StateMachines::BlacklistMatcher.new(:parked)
-    @branch = StateMachines::Branch.new(@matcher => :idling)
-  end
-
-  def test_should_not_convert_from_to_whitelist_matcher
-    assert_equal @matcher, @branch.state_requirements.first[:from]
-  end
-
-  def test_should_convert_to_to_whitelist_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.state_requirements.first[:to]
-  end
-end

data/test/unit/branch/branch_with_multiple_if_conditionals_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleIfConditionalsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_match_if_all_are_true
-    branch = StateMachines::Branch.new(if: [lambda { true }, lambda { true }])
-    assert branch.match(@object)
-  end
-
-  def test_should_not_match_if_any_are_false
-    branch = StateMachines::Branch.new(if: [lambda { true }, lambda { false }])
-    refute branch.match(@object)
-
-    branch = StateMachines::Branch.new(if: [lambda { false }, lambda { true }])
-    refute branch.match(@object)
-  end
-end

data/test/unit/branch/branch_with_multiple_implicit_requirements_test.rb

@@ -1,53 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleImplicitRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(parked: :idling, idling: :first_gear, on: :ignite)
-  end
-
-  def test_should_create_multiple_state_requirements
-    assert_equal 2, @branch.state_requirements.length
-  end
-
-  def test_should_not_match_event_as_state_requirement
-    refute @branch.matches?(@object, from: :on, to: :ignite)
-  end
-
-  def test_should_match_if_from_included_in_any
-    assert @branch.matches?(@object, from: :parked)
-    assert @branch.matches?(@object, from: :idling)
-  end
-
-  def test_should_not_match_if_from_not_included_in_any
-    refute @branch.matches?(@object, from: :first_gear)
-  end
-
-  def test_should_match_if_to_included_in_any
-    assert @branch.matches?(@object, to: :idling)
-    assert @branch.matches?(@object, to: :first_gear)
-  end
-
-  def test_should_not_match_if_to_not_included_in_any
-    refute @branch.matches?(@object, to: :parked)
-  end
-
-  def test_should_match_if_all_options_match
-    assert @branch.matches?(@object, from: :parked, to: :idling, on: :ignite)
-    assert @branch.matches?(@object, from: :idling, to: :first_gear, on: :ignite)
-  end
-
-  def test_should_not_match_if_any_options_do_not_match
-    refute @branch.matches?(@object, from: :parked, to: :idling, on: :park)
-    refute @branch.matches?(@object, from: :parked, to: :first_gear, on: :park)
-  end
-
-  def test_should_include_all_known_states
-    assert_equal [:first_gear, :idling, :parked], @branch.known_states.sort_by { |state| state.to_s }
-  end
-
-  def test_should_not_duplicate_known_statse
-    branch = StateMachines::Branch.new(parked: :idling, first_gear: :idling)
-    assert_equal [:first_gear, :idling, :parked], branch.known_states.sort_by { |state| state.to_s }
-  end
-end

data/test/unit/branch/branch_with_multiple_to_requirements_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleToRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(to: [:idling, :parked])
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, to: :idling)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, to: :first_gear)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:idling, :parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_multiple_unless_conditionals_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithMultipleUnlessConditionalsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_match_if_all_are_false
-    branch = StateMachines::Branch.new(unless: [lambda { false }, lambda { false }])
-    assert branch.match(@object)
-  end
-
-  def test_should_not_match_if_any_are_true
-    branch = StateMachines::Branch.new(unless: [lambda { true }, lambda { false }])
-    refute branch.match(@object)
-
-    branch = StateMachines::Branch.new(unless: [lambda { false }, lambda { true }])
-    refute branch.match(@object)
-  end
-end

data/test/unit/branch/branch_with_nil_requirements_test.rb

@@ -1,28 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithNilRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(from: nil, to: nil)
-  end
-
-  def test_should_match_empty_query
-    assert @branch.matches?(@object)
-  end
-
-  def test_should_match_if_all_requirements_match
-    assert @branch.matches?(@object, from: nil, to: nil)
-  end
-
-  def test_should_not_match_if_from_not_included
-    refute @branch.matches?(@object, from: :parked)
-  end
-
-  def test_should_not_match_if_to_not_included
-    refute @branch.matches?(@object, to: :idling)
-  end
-
-  def test_should_include_all_known_states
-    assert_equal [nil], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_no_requirements_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithNoRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new
-  end
-
-  def test_should_use_all_matcher_for_event_requirement
-    assert_equal StateMachines::AllMatcher.instance, @branch.event_requirement
-  end
-
-  def test_should_use_all_matcher_for_from_state_requirement
-    assert_equal StateMachines::AllMatcher.instance, @branch.state_requirements.first[:from]
-  end
-
-  def test_should_use_all_matcher_for_to_state_requirement
-    assert_equal StateMachines::AllMatcher.instance, @branch.state_requirements.first[:to]
-  end
-
-  def test_should_match_empty_query
-    assert @branch.matches?(@object, {})
-  end
-
-  def test_should_match_non_empty_query
-    assert @branch.matches?(@object, to: :idling, from: :parked, on: :ignite)
-  end
-
-  def test_should_include_all_requirements_in_match
-    match = @branch.match(@object, {})
-
-    assert_equal @branch.state_requirements.first[:from], match[:from]
-    assert_equal @branch.state_requirements.first[:to], match[:to]
-    assert_equal @branch.event_requirement, match[:on]
-  end
-end

data/test/unit/branch/branch_with_on_matcher_requirement_test.rb

@@ -1,16 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithOnMatcherRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(on: StateMachines::BlacklistMatcher.new([:ignite, :park]))
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, on: :shift_up)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, on: :ignite)
-  end
-end