transitions 1.0.0 → 1.0.1

data/test/active_record/test_active_record_scopes.rb

@@ -1,64 +0,0 @@
-require 'helper'
-
-class CreateBunnies < ActiveRecord::Migration
-  def self.up
-    create_table(:bunnies, force: true) do |t|
-      t.string :status # Explicitly use another state column to ensure that this whole enchilada is working with other state column names than the default ones.
-    end
-  end
-end
-
-class CreatePuppies < ActiveRecord::Migration
-  def self.up
-    create_table(:puppies, force: true) do |t|
-      t.string :state
-    end
-  end
-end
-
-class Bunny < ActiveRecord::Base
-  include ActiveModel::Transitions
-
-  state_machine attribute_name: :status, auto_scopes: true do
-    state :hobbling
-  end
-end
-
-class Puppy < ActiveRecord::Base
-  include ActiveModel::Transitions
-
-  state_machine do
-    state :barking
-  end
-end
-
-class TestScopes < Test::Unit::TestCase
-  def setup
-    set_up_db CreateBunnies, CreatePuppies
-    @bunny = Bunny.create!
-  end
-
-  test 'scopes exist' do
-    assert_respond_to Bunny, :hobbling
-  end
-
-  test 'scope returns correct object' do
-    assert_equal Bunny.hobbling.first, @bunny
-  end
-
-  test 'scopes are only generated if we explicitly say so' do
-    assert_not_respond_to Puppy, :barking
-  end
-
-  test 'scope generation raises an exception if we try to overwrite an existing method' do
-    assert_raise(Transitions::InvalidMethodOverride) do
-      Class.new(ActiveRecord::Base) do
-        include ActiveModel::Transitions
-
-        state_machine auto_scopes: true do
-          state :new
-        end
-      end
-    end
-  end
-end

data/test/active_record/test_active_record_timestamps.rb

@@ -1,132 +0,0 @@
-require 'helper'
-
-class CreateOrders < ActiveRecord::Migration
-  def self.up
-    create_table(:orders, force: true) do |t|
-      t.string :state
-      t.string :order_number
-      t.datetime :paid_at
-      t.datetime :prepared_on
-      t.datetime :dispatched_at
-      t.date :cancellation_date
-      t.boolean :allow_transition, default: true
-    end
-  end
-end
-
-class Order < ActiveRecord::Base
-  include ActiveModel::Transitions
-
-  state_machine do
-    state :opened
-    state :placed
-    state :paid
-    state :prepared
-    state :delivered
-    state :cancelled
-
-    # no timestamp col is being specified here - should be ignored
-    event :place do
-      transitions from: :opened, to: :placed
-    end
-
-    # should set paid_at timestamp
-    event :pay, timestamp: true do
-      transitions from: :placed, to: :paid, guard: lambda { |obj| obj.allow_transition }
-    end
-
-    # should set prepared_on
-    event :prepare, timestamp: true do
-      transitions from: :paid, to: :prepared
-    end
-
-    # should set dispatched_at
-    event :deliver, timestamp: 'dispatched_at' do
-      transitions from: :prepared, to: :delivered
-    end
-
-    # should set cancellation_date
-    event :cancel, timestamp: :cancellation_date do
-      transitions from: [:placed, :paid, :prepared], to: :cancelled
-    end
-
-    # should raise an exception as there is no timestamp col
-    event :reopen, timestamp: true do
-      transitions from: :cancelled, to: :opened
-    end
-  end
-end
-
-class TestActiveRecordTimestamps < Test::Unit::TestCase
-  require 'securerandom'
-
-  def setup
-    set_up_db CreateOrders
-  end
-
-  def create_order(state = nil)
-    Order.create! order_number: SecureRandom.hex(4), state: state
-  end
-
-  # control case, no timestamp has been set so we should expect default behaviour
-  test 'moving to placed does not raise any exceptions' do
-    @order = create_order
-    assert_nothing_raised { @order.place! }
-    assert_equal @order.state, 'placed'
-  end
-
-  test 'moving to paid should set paid_at' do
-    @order = create_order(:placed)
-    @order.pay!
-    @order.reload
-    assert_not_nil @order.paid_at
-  end
-
-  test 'moving to paid should not set paid_at if our guard evaluates to false' do
-    @order = create_order(:placed)
-    @order.update_attribute :allow_transition, false
-    @order.pay!
-    @order.reload
-    assert_nil @order.paid_at
-  end
-
-  test 'moving to prepared should set prepared_on' do
-    @order = create_order(:paid)
-    @order.prepare!
-    @order.reload
-    assert_not_nil @order.prepared_on
-  end
-
-  test 'moving to delivered should set dispatched_at' do
-    @order = create_order(:prepared)
-    @order.deliver!
-    @order.reload
-    assert_not_nil @order.dispatched_at
-  end
-
-  test 'moving to cancelled should set cancellation_date' do
-    @order = create_order(:placed)
-    @order.cancel!
-    @order.reload
-    assert_not_nil @order.cancellation_date
-  end
-
-  test 'moving to reopened should raise an exception as there is no attribute' do
-    @order = create_order(:cancelled)
-    assert_raise(NoMethodError) { @order.re_open! }
-    @order.reload
-  end
-
-  test 'passing an invalid value to timestamp options should raise an exception' do
-    assert_raise(ArgumentError) do
-      class Order < ActiveRecord::Base
-        include ActiveModel::Transitions
-        state_machine do
-          event :replace, timestamp: 1 do
-            transitions from: :prepared, to: :placed
-          end
-        end
-      end
-    end
-  end
-end

data/test/active_record/test_custom_select.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-# Regression test for https://github.com/troessner/transitions/issues/95
-class CreateSwitches < ActiveRecord::Migration
-  def self.up
-    create_table(:switches, force: true) do |t|
-      t.string :state
-    end
-  end
-end
-
-class Switch < ActiveRecord::Base
-  include ActiveModel::Transitions
-
-  state_machine do
-    state :off
-    state :on
-  end
-end
-
-class TestCustomSelect < Test::Unit::TestCase
-  def setup
-    set_up_db CreateSwitches
-    Switch.create!
-  end
-
-  test 'should not trigger an exception when we use a custom select query which excludes the name of our state attribute' do
-    result = Switch.select(:id)
-    assert_nothing_raised NoMethodError do
-      result.inspect
-    end
-  end
-end

data/test/event/test_event.rb

@@ -1,72 +0,0 @@
-require 'helper'
-
-class TestEvent < Test::Unit::TestCase
-  def setup
-    @state_name = :close_order
-    @success_as_symbol = :success_callback
-    @success_as_lambda = lambda { |record| record.success_callback }
-    @success_as_array  = [@success_as_symbol, @success_as_lambda]
-  end
-
-  def event_with_symbol_success_callback
-    @event = Transitions::Event.new(nil, @state_name, success: @success_as_symbol) do
-      transitions to: :closed, from: [:open, :received]
-    end
-  end
-  alias_method :new_event, :event_with_symbol_success_callback
-
-  def event_with_lambda_success_callback
-    @event = Transitions::Event.new(nil, @state_name, success: @success_as_lambda) do
-      transitions to: :closed, from: [:open, :received]
-    end
-  end
-
-  def event_with_array_success_callback
-    @event = Transitions::Event.new(nil, @state_name, success: @success_as_array) do
-      transitions to: :closed, from: [:open, :received]
-    end
-  end
-
-  test 'should set the name' do
-    assert_equal @state_name, new_event.name
-  end
-
-  test 'should set the success callback with a symbol and return a block' do
-    assert_respond_to event_with_symbol_success_callback.success, :call
-  end
-
-  test 'should build a block which calls the given success_callback symbol on the passed record instance' do
-    record = mock('SomeRecordToGetCalled')
-    record.expects(:success_callback)
-
-    event_with_symbol_success_callback.success.call(record)
-  end
-
-  test 'should set the success callback with a lambda' do
-    assert_respond_to event_with_lambda_success_callback.success, :call
-  end
-
-  test 'should build a block which calls the given success_callback lambda on the passed record instance' do
-    record = mock('SomeRecordToGetCalled')
-    record.expects(:success_callback)
-
-    event_with_lambda_success_callback.success.call(record)
-  end
-
-  test 'should set the success callback with an array' do
-    assert_respond_to event_with_array_success_callback.success, :call
-  end
-
-  test 'should build a block which calls the given success_callback array on the passed record instance for each callback' do
-    record = mock('SomeRecordToGetCalled')
-    record.expects(:success_callback).twice
-
-    event_with_array_success_callback.success.call(record)
-  end
-
-  test 'should create StateTransitions' do
-    Transitions::StateTransition.expects(:new).with(to: :closed, from: :open)
-    Transitions::StateTransition.expects(:new).with(to: :closed, from: :received)
-    new_event
-  end
-end

data/test/event/test_event_arguments.rb

@@ -1,29 +0,0 @@
-require 'helper'
-
-class ArgumentsTestSubject
-  include Transitions
-  attr_accessor :date
-
-  state_machine do
-    state :initial
-    state :opened
-
-    event :open do
-      transitions from: :initial, to: :opened, on_transition: :update_date
-    end
-  end
-
-  def update_date(date = Date.today)
-    self.date = date
-  end
-end
-
-class StateMachineMachineTest < Test::Unit::TestCase
-  test 'pass arguments to transition method' do
-    subject = ArgumentsTestSubject.new
-    assert_equal :initial, subject.current_state
-    subject.open!(Date.yesterday)
-    assert_equal :opened, subject.current_state
-    assert_equal Date.yesterday, subject.date
-  end
-end

data/test/event/test_event_being_fired.rb

@@ -1,26 +0,0 @@
-require 'helper'
-
-class TestEventBeingFired < Test::Unit::TestCase
-  test 'should raise an Transitions::InvalidTransition error if the transitions are empty' do
-    event = Transitions::Event.new(nil, :event_that_is_fired)
-    class AnotherDummy; end
-    obj = AnotherDummy.new
-    obj.stubs(:current_state).returns(:running)
-
-    exception = assert_raise Transitions::InvalidTransition do
-      event.fire(obj)
-    end
-    assert_match /Can't fire event `event_that_is_fired` in current state `running` for `TestEventBeingFired::AnotherDummy`/, exception.message
-  end
-
-  test 'should return the state of the first matching transition it finds' do
-    event = Transitions::Event.new(nil, :event) do
-      transitions to: :closed, from: [:open, :received]
-    end
-
-    obj = stub
-    obj.stubs(:current_state).returns(:open)
-
-    assert_equal :closed, event.fire(obj)
-  end
-end

data/test/event/test_event_checks.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-class ChecksTestSubject
-  include Transitions
-
-  state_machine initial: :initial do
-    state :initial
-    state :opened
-    state :closed
-
-    event :open do
-      transitions from: :initial, to: :opened
-    end
-
-    event :close do
-      transitions from: :opened, to: :closed
-    end
-  end
-end
-
-class StateMachineChecksTest < Test::Unit::TestCase
-  test 'checks if a given transition is possible' do
-    subject = ChecksTestSubject.new
-    assert_equal :initial, subject.current_state
-    assert_equal true, subject.can_open?
-    assert_equal false, subject.can_close?
-
-    subject.open
-
-    assert_equal false, subject.can_open?
-    assert_equal true, subject.can_close?
-  end
-end

data/test/helper.rb

@@ -1,18 +0,0 @@
-require 'test/unit'
-require 'active_record'
-
-require 'transitions'
-require 'active_model/transitions'
-
-require 'mocha'
-require 'random_data'
-
-def db_defaults!
-  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-  ActiveRecord::Migration.verbose = false
-end
-
-def set_up_db(*migrations)
-  db_defaults!
-  migrations.each { |klass| klass.send :migrate, :up }
-end

data/test/machine/machine_template.rb

@@ -1,27 +0,0 @@
-class MachineTestSubject
-  include Transitions
-
-  state_machine initial: :open do
-    state :open
-    state :closed
-
-    event :shutdown do
-      transitions from: :open, to: :closed
-    end
-
-    event :timeout do
-      transitions from: :open, to: :closed
-    end
-
-    event :restart do
-      transitions from: :closed, to: :open, guard: :restart_allowed?
-    end
-  end
-
-  def restart_allowed?(allowed = true)
-    allowed
-  end
-
-  def event_failed(*)
-  end
-end