aasm 2.1.1 → 5.2.0

data/spec/unit/namespaced_multiple_example_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:namespaced) { NamespacedMultipleExample.new }
+
+  it 'starts with an initial state' do
+    expect(namespaced.aasm(:status).current_state).to eq(:unapproved)
+    expect(namespaced).to respond_to(:unapproved?)
+    expect(namespaced).to be_unapproved
+
+    expect(namespaced.aasm(:review_status).current_state).to eq(:unapproved)
+    expect(namespaced).to respond_to(:review_unapproved?)
+    expect(namespaced).to be_review_unapproved
+
+    expect(namespaced.aasm(:car).current_state).to eq(:unsold)
+    expect(namespaced).to respond_to(:car_unsold?)
+    expect(namespaced).to be_car_unsold
+  end
+
+  it 'allows transitions to other states' do
+    expect(namespaced).to respond_to(:approve)
+    expect(namespaced).to respond_to(:approve!)
+    namespaced.approve!
+    expect(namespaced).to respond_to(:approved?)
+    expect(namespaced).to be_approved
+
+    expect(namespaced).to respond_to(:approve_review)
+    expect(namespaced).to respond_to(:approve_review!)
+    namespaced.approve_review!
+    expect(namespaced).to respond_to(:review_approved?)
+    expect(namespaced).to be_review_approved
+
+    expect(namespaced).to respond_to(:sell_car)
+    expect(namespaced).to respond_to(:sell_car!)
+    namespaced.sell_car!
+    expect(namespaced).to respond_to(:car_sold?)
+    expect(namespaced).to be_car_sold
+  end
+
+  it 'denies transitions to other states' do
+    expect {namespaced.unapprove}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.unapprove!}.to raise_error(AASM::InvalidTransition)
+    namespaced.approve
+    expect {namespaced.approve}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.approve!}.to raise_error(AASM::InvalidTransition)
+    namespaced.unapprove
+
+    expect {namespaced.unapprove_review}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.unapprove_review!}.to raise_error(AASM::InvalidTransition)
+    namespaced.approve_review
+    expect {namespaced.approve_review}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.approve_review!}.to raise_error(AASM::InvalidTransition)
+    namespaced.unapprove_review
+
+    expect {namespaced.return_car}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.return_car!}.to raise_error(AASM::InvalidTransition)
+    namespaced.sell_car
+    expect {namespaced.sell_car}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.sell_car!}.to raise_error(AASM::InvalidTransition)
+    namespaced.return_car
+  end
+
+  it 'defines constants for each state name' do
+    expect(NamespacedMultipleExample::STATE_UNAPPROVED).to eq(:unapproved)
+    expect(NamespacedMultipleExample::STATE_APPROVED).to eq(:approved)
+
+    expect(NamespacedMultipleExample::STATE_REVIEW_UNAPPROVED).to eq(:unapproved)
+    expect(NamespacedMultipleExample::STATE_REVIEW_APPROVED).to eq(:approved)
+
+    expect(NamespacedMultipleExample::STATE_CAR_UNSOLD).to eq(:unsold)
+    expect(NamespacedMultipleExample::STATE_CAR_SOLD).to eq(:sold)
+  end
+
+
+end

data/spec/unit/new_dsl_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "the new dsl" do
+
+  let(:process) {ProcessWithNewDsl.new}
+
+  it 'should not conflict with other event or state methods' do
+    expect {ProcessWithNewDsl.state}.to raise_error(RuntimeError, "wrong state method")
+    expect {ProcessWithNewDsl.event}.to raise_error(RuntimeError, "wrong event method")
+  end
+
+end

data/spec/unit/override_warning_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe 'warns when overrides a method' do
+  before do
+    AASM::Configuration.hide_warnings = false
+  end
+
+  after do
+    AASM::Configuration.hide_warnings = true
+  end
+
+  module Clumsy
+    def self.included base
+      base.send :include, AASM
+
+      base.aasm do
+        state :valid
+        event(:save) { }
+      end
+    end
+  end
+
+  module WithEnumBase
+    def self.included base
+      base.send :include, AASM
+      base.instance_eval do
+        def defined_enums
+          { 'state' => { 'valid' => 0, 'invalid' => 1 } }
+        end
+      end
+      base.aasm enum: true do
+        state :valid
+        event(:save) { }
+      end
+    end
+  end
+
+  describe 'state' do
+    let(:base_klass) do
+      Class.new do
+        def valid?; end
+      end
+    end
+
+    subject { base_klass.send :include, Clumsy }
+
+    it 'should log to warn' do
+      expect_any_instance_of(Logger).to receive(:warn).with(": overriding method 'valid?'!")
+      subject
+    end
+  end
+
+  describe 'enum' do
+    let(:enum_base_klass) do
+      Class.new do
+        def valid?; end
+      end
+    end
+
+    subject { enum_base_klass.send :include, WithEnumBase }
+
+    it 'should not log to warn' do
+      expect_any_instance_of(Logger).to receive(:warn).never
+      subject
+    end
+  end
+
+  describe 'event' do
+    context 'may?' do
+      let(:base_klass) do
+        Class.new do
+          def may_save?; end
+          def save!; end
+          def save; end
+        end
+      end
+
+      subject { base_klass.send :include, Clumsy }
+
+      it 'should log to warn' do
+        expect_any_instance_of(Logger).to receive(:warn).exactly(3).times do |logger, message|
+          expect(
+            [
+              ": overriding method 'may_save?'!",
+              ": overriding method 'save!'!",
+              ": overriding method 'save'!"
+            ]
+          ).to include(message)
+        end
+        subject
+      end
+    end
+  end
+end