state_machines 0.0.2 → 0.1.0

data/spec/state_machines/helper_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe StateMachines::HelperModule do
-  let(:klass) { Class.new }
-  let(:machine) { StateMachines::Machine.new(klass) }
-  let(:helper_module) { StateMachines::HelperModule.new(machine, :instance) }
-  it 'should not have a name' do
-    expect(helper_module.name.to_s).to eq('')
-  end
-
-  it 'should_provide_human_readable_to_s' do
-    expect(helper_module.to_s).to eq("#{klass} :state instance helpers")
-  end
-end

data/spec/state_machines/integration_base_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe StateMachines::Integrations::Base do
-  it { should respond_to(:name) }
-  it { should respond_to(:integration_name) }
-  it { should respond_to(:available?) }
-  it { should respond_to(:matching_ancestors) }
-  it { should respond_to(:matches?) }
-  it { should respond_to(:matches_ancestors?) }
-  it { expect(subject.name).to eq('StateMachines::Integrations::Base') }
-  it { expect(subject.integration_name).to eq(:base) }
-end

data/spec/state_machines/integration_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-describe StateMachines::Integrations do
-
-  it { expect(StateMachines::Integrations).to respond_to(:register) }
-  it { expect(StateMachines::Integrations).to respond_to(:integrations) }
-  it { expect(StateMachines::Integrations).to respond_to(:match) }
-  it { expect(StateMachines::Integrations).to respond_to(:match_ancestors) }
-  it { expect(StateMachines::Integrations).to respond_to(:find_by_name) }
-  describe '#register' do
-    before(:each) do
-      StateMachines::Integrations.const_set('Custom', Module.new do
-        include StateMachines::Integrations::Base
-      end)
-    end
-
-    it 'should register integration' do
-      expect(StateMachines::Integrations.register(StateMachines::Integrations::Custom)).to be_truthy
-    end
-
-    after(:each) do
-      StateMachines::Integrations.send(:remove_const, 'Custom')
-      StateMachines::Integrations.send(:reset)
-    end
-
-  end
-
-  describe '#integrations' do
-    before(:each) do
-      StateMachines::Integrations.const_set('Custom', Module.new do
-        include StateMachines::Integrations::Base
-      end)
-      StateMachines::Integrations.register(StateMachines::Integrations::Custom)
-    end
-
-    it 'should register integration' do
-      expect(StateMachines::Integrations.integrations).to include(StateMachines::Integrations::Custom)
-    end
-
-    after(:each) do
-      StateMachines::Integrations.send(:remove_const, 'Custom')
-      StateMachines::Integrations.send(:reset)
-    end
-  end
-
-  context 'do' do
-    before(:all) do
-      Object.const_set('CustomIntegration', Module.new do
-        include StateMachines::Integrations::Base
-        class << self
-          def matching_ancestors
-            %w(Bar)
-          end
-        end
-      end)
-      StateMachines::Integrations.const_set('Hogue', Module.new do
-        include StateMachines::Integrations::Base
-        class << self
-          def matching_ancestors
-            %w(Hogue Foo)
-          end
-        end
-      end)
-      class Bar
-      end
-      class Hogue
-      end
-      class Foo
-      end
-
-      StateMachines::Integrations.register(CustomIntegration)
-    end
-
-    describe 'StateMachines::Integrations::Hogue' do
-      let(:subject) { StateMachines::Integrations::Hogue }
-      it { should respond_to(:name) }
-      it { should respond_to(:integration_name) }
-      it { should respond_to(:available?) }
-      it { should respond_to(:matching_ancestors) }
-      it { should respond_to(:matches?) }
-      it { should respond_to(:matches_ancestors?) }
-      it { expect(subject.name).to eq('StateMachines::Integrations::Hogue') }
-      it { expect(subject.matching_ancestors).to eq(%w(Hogue Foo)) }
-    end
-
-    describe 'CustomIntegration' do
-      let(:subject) { CustomIntegration }
-      it { should respond_to(:name) }
-      it { should respond_to(:integration_name) }
-      it { should respond_to(:available?) }
-      it { should respond_to(:matching_ancestors) }
-      it { should respond_to(:matches?) }
-      it { should respond_to(:matches_ancestors?) }
-      it { expect(subject.name).to eq('CustomIntegration') }
-      it { expect(subject.integration_name).to eq(:custom_integration) }
-      it { expect(subject.matching_ancestors).to eq(%w(Bar)) }
-    end
-
-    describe '#match' do
-
-
-      it 'should match correct integration' do
-
-        expect(StateMachines::Integrations.match(Bar)).to eq(CustomIntegration)
-        expect(StateMachines::Integrations.match(Hogue)).to eq(StateMachines::Integrations::Hogue)
-        expect(StateMachines::Integrations.match(Foo)).to eq(StateMachines::Integrations::Hogue)
-      end
-
-
-    end
-
-    describe '#match_ancestors' do
-      it { expect(StateMachines::Integrations.match_ancestors([])).to be_nil }
-      it { expect(StateMachines::Integrations.match_ancestors(['Foo'])).to eq(StateMachines::Integrations::Hogue) }
-      it { expect(StateMachines::Integrations.match_ancestors(['Hogue'])).to eq(StateMachines::Integrations::Hogue) }
-      it { expect(StateMachines::Integrations.match_ancestors(['Foo', 'Hogue'])).to eq(StateMachines::Integrations::Hogue) }
-      it { expect(StateMachines::Integrations.match_ancestors(['Bar'])).to eq(CustomIntegration) }
-    end
-
-    describe '#find_by_name' do
-     pending
-    end
-
-    after(:all) do
-      Object.send(:remove_const, 'CustomIntegration')
-      StateMachines::Integrations.send(:remove_const, 'Hogue')
-      StateMachines::Integrations.send(:reset)
-    end
-  end
-
-
-end

data/spec/state_machines/invalid_parallel_transition_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe StateMachines::InvalidParallelTransition do
-  before(:each) do
-    @object = Object.new
-    @events = [:ignite, :disable_alarm]
-
-    @invalid_transition = StateMachines::InvalidParallelTransition.new(@object, @events)
-  end
-
-  it 'should_have_an_object' do
-    expect(@invalid_transition.object).to eq(@object)
-  end
-
-  it 'should_have_events' do
-    expect(@invalid_transition.events).to eq(@events)
-  end
-end

data/spec/state_machines/invalid_transition_spec.rb

@@ -1,114 +0,0 @@
-context 'Default' do
-  before(:each) do
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @state = @machine.state :parked
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :ignite)
-  end
-
-  it 'should_have_an_object' do
-    assert_equal @object, @invalid_transition.object
-  end
-
-  it 'should_have_a_machine' do
-    assert_equal @machine, @invalid_transition.machine
-  end
-
-  it 'should_have_an_event' do
-    assert_equal :ignite, @invalid_transition.event
-  end
-
-  it 'should_have_a_qualified_event' do
-    assert_equal :ignite, @invalid_transition.qualified_event
-  end
-
-  it 'should_have_a_from_value' do
-    assert_equal 'parked', @invalid_transition.from
-  end
-
-  it 'should_have_a_from_name' do
-    assert_equal :parked, @invalid_transition.from_name
-  end
-
-  it 'should_have_a_qualified_from_name' do
-    assert_equal :parked, @invalid_transition.qualified_from_name
-  end
-
-  it 'should_generate_a_message' do
-    assert_equal 'Cannot transition state via :ignite from :parked', @invalid_transition.message
-  end
-end
-
-context 'WithNamespace' do
-  before(:each) do
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, :namespace => 'alarm')
-    @state = @machine.state :active
-    @machine.event :disable
-
-    @object = @klass.new
-    @object.state = 'active'
-
-    @invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :disable)
-  end
-
-  it 'should_have_an_event' do
-    assert_equal :disable, @invalid_transition.event
-  end
-
-  it 'should_have_a_qualified_event' do
-    assert_equal :disable_alarm, @invalid_transition.qualified_event
-  end
-
-  it 'should_have_a_from_name' do
-    assert_equal :active, @invalid_transition.from_name
-  end
-
-  it 'should_have_a_qualified_from_name' do
-    assert_equal :alarm_active, @invalid_transition.qualified_from_name
-  end
-end
-
-context 'WithIntegration' do
-  before(:each) do
-    StateMachines::Integrations.const_set('Custom', Module.new do
-      include StateMachines::Integrations::Base
-
-      def errors_for(object)
-        object.errors
-      end
-    end)
-
-    @klass = Class.new do
-      attr_accessor :errors
-    end
-    @machine = StateMachines::Machine.new(@klass, :integration => :custom)
-    @machine.state :parked
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  it 'should_generate_a_message_without_reasons_if_empty' do
-    @object.errors = ''
-    invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :ignite)
-    assert_equal 'Cannot transition state via :ignite from :parked', invalid_transition.message
-  end
-
-  it 'should_generate_a_message_with_error_reasons_if_errors_found' do
-    @object.errors = 'Id is invalid, Name is invalid'
-    invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :ignite)
-    assert_equal 'Cannot transition state via :ignite from :parked (Reason(s): Id is invalid, Name is invalid)', invalid_transition.message
-  end
-
-  after(:each) do
-    StateMachines::Integrations.send(:remove_const, 'Custom')
-    StateMachines::Integrations.send(:reset)
-  end
-end