state_machines 0.0.2 → 0.1.0

data/test/unit/assertions/assert_exclusive_keys_test.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+
+class AssertExclusiveKeysTest < StateMachinesTest
+  def test_should_not_raise_exception_if_no_keys_found
+    { on: :park }.assert_exclusive_keys(:only, :except)
+  end
+
+  def test_should_not_raise_exception_if_one_key_found
+    { only: :parked }.assert_exclusive_keys(:only, :except)
+    { except: :parked }.assert_exclusive_keys(:only, :except)
+  end
+
+  def test_should_raise_exception_if_two_keys_found
+    exception = assert_raises(ArgumentError) { { only: :parked, except: :parked }.assert_exclusive_keys(:only, :except) }
+    assert_equal 'Conflicting keys: only, except', exception.message
+  end
+
+  def test_should_raise_exception_if_multiple_keys_found
+    exception = assert_raises(ArgumentError) { { only: :parked, except: :parked, on: :park }.assert_exclusive_keys(:only, :except, :with) }
+    assert_equal 'Conflicting keys: only, except', exception.message
+  end
+end

data/test/unit/assertions/assert_valid_key_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../test_helper'
+
+class AssertValidKeysTest < StateMachinesTest
+  def test_should_not_raise_exception_if_key_is_valid
+    { name: 'foo', value: 'bar' }.assert_valid_keys(:name, :value, :force)
+  end
+
+  def test_should_raise_exception_if_key_is_invalid
+    exception = assert_raises(ArgumentError) { { name: 'foo', value: 'bar', invalid: true }.assert_valid_keys(:name, :value, :force) }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :name, :value, :force', exception.message
+  end
+end

data/test/unit/branch/branch_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../test_helper'
+
+class BranchTest < StateMachinesTest
+  def setup
+    @branch = StateMachines::Branch.new(from: :parked, to: :idling)
+  end
+
+  def test_should_not_raise_exception_if_implicit_option_specified
+    StateMachines::Branch.new(invalid: :valid)
+  end
+
+  def test_should_not_have_an_if_condition
+    assert_nil @branch.if_condition
+  end
+
+  def test_should_not_have_an_unless_condition
+    assert_nil @branch.unless_condition
+  end
+
+  def test_should_have_a_state_requirement
+    assert_equal 1, @branch.state_requirements.length
+  end
+
+  def test_should_raise_an_exception_if_invalid_match_option_specified
+    exception = assert_raises(ArgumentError) { @branch.match(Object.new, invalid: true) }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :from, :to, :on, :guard', exception.message
+  end
+end

data/test/unit/branch/branch_with_conflicting_conditionals_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../test_helper'
+
+class BranchWithConflictingConditionalsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_match_if_if_is_true_and_unless_is_false
+    branch = StateMachines::Branch.new(if: lambda { true }, unless: lambda { false })
+    assert branch.match(@object)
+  end
+
+  def test_should_not_match_if_if_is_false_and_unless_is_true
+    branch = StateMachines::Branch.new(if: lambda { false }, unless: lambda { true })
+    refute branch.match(@object)
+  end
+
+  def test_should_not_match_if_if_is_false_and_unless_is_false
+    branch = StateMachines::Branch.new(if: lambda { false }, unless: lambda { false })
+    refute branch.match(@object)
+  end
+
+  def test_should_not_match_if_if_is_true_and_unless_is_true
+    branch = StateMachines::Branch.new(if: lambda { true }, unless: lambda { true })
+    refute branch.match(@object)
+  end
+end

data/test/unit/branch/branch_with_conflicting_from_requirements_test.rb

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,53 @@
+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_on_requirements_test.rb

@@ -0,0 +1,20 @@
+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