state_machines-activerecord 0.9.0 → 0.31.0

data/test/machine_with_static_initial_state_test.rb

@@ -1,167 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithStaticInitialStateTest < BaseTestCase
-  def setup
-    @model = new_model(:vehicle) do
-      attr_accessor :value
-    end
-    @machine = StateMachines::Machine.new(@model, :initial => :parked)
-  end
-
-  def test_should_set_initial_state_on_created_object
-    record = @model.new
-    assert_equal 'parked', record.state
-  end
-
-  def test_should_set_initial_state_with_nil_attributes
-    record = @model.new(nil)
-    assert_equal 'parked', record.state
-  end
-
-  def test_should_still_set_attributes
-    record = @model.new(:value => 1)
-    assert_equal 1, record.value
-  end
-
-  def test_should_still_allow_initialize_blocks
-    block_args = nil
-    record = @model.new do |*args|
-      block_args = args
-    end
-
-    assert_equal [record], block_args
-  end
-
-  def test_should_set_attributes_prior_to_initialize_block
-    state = nil
-    @model.new do |record|
-      state = record.state
-    end
-
-    assert_equal 'parked', state
-  end
-
-  def test_should_set_attributes_prior_to_after_initialize_hook
-    state = nil
-    @model.after_initialize do |record|
-      state = record.state
-    end
-    @model.new
-    assert_equal 'parked', state
-  end
-
-  def test_should_set_initial_state_before_setting_attributes
-    @model.class_eval do
-      attr_accessor :state_during_setter
-
-      remove_method :value=
-      define_method(:value=) do |value|
-        self.state_during_setter = state
-      end
-    end
-    record = @model.new
-    record.value = 1
-    assert_equal 'parked', record.state_during_setter
-  end
-
-  def test_should_not_set_initial_state_after_already_initialized
-    record = @model.new(:value => 1)
-    assert_equal 'parked', record.state
-
-    record.state = 'idling'
-    record.attributes = {}
-    assert_equal 'idling', record.state
-  end
-
-  def test_should_persist_initial_state
-    record = @model.new
-    record.save
-    record.reload
-    assert_equal 'parked', record.state
-  end
-
-  def test_should_persist_initial_state_on_dup
-    record = @model.create.dup
-    record.save
-    record.reload
-    assert_equal 'parked', record.state
-  end
-
-  def test_should_use_stored_values_when_loading_from_database
-    @machine.state :idling
-
-    record = @model.find(@model.create(:state => 'idling').id)
-    assert_equal 'idling', record.state
-  end
-
-  def test_should_use_stored_values_when_loading_from_database_with_nil_state
-    @machine.state nil
-
-    record = @model.find(@model.create(:state => nil).id)
-    assert_nil record.state
-  end
-
-  def test_should_use_stored_values_when_loading_for_many_association
-    @machine.state :idling
-
-    @model.connection.add_column @model.table_name, :owner_id, :integer
-    @model.reset_column_information
-    MachineWithStaticInitialStateTest.const_set('Vehicle', @model)
-
-    owner_model = new_model(:owner) do
-      has_many :vehicles, :class_name => 'MachineWithStaticInitialStateTest::Vehicle'
-    end
-    MachineWithStaticInitialStateTest.const_set('Owner', owner_model)
-
-    owner = owner_model.create
-    @model.create(:state => 'idling', :owner_id => owner.id)
-    assert_equal 'idling', owner.vehicles[0].state
-  end
-
-  def test_should_use_stored_values_when_loading_for_one_association
-    @machine.state :idling
-
-    @model.connection.add_column @model.table_name, :owner_id, :integer
-    @model.reset_column_information
-    MachineWithStaticInitialStateTest.const_set('Vehicle', @model)
-
-    owner_model = new_model(:owner) do
-      has_one :vehicle, :class_name => 'MachineWithStaticInitialStateTest::Vehicle'
-    end
-    MachineWithStaticInitialStateTest.const_set('Owner', owner_model)
-
-    owner = owner_model.create
-    @model.create(:state => 'idling', :owner_id => owner.id)
-    assert_equal 'idling', owner.vehicle.state
-  end
-
-  def test_should_use_stored_values_when_loading_for_belongs_to_association
-    @machine.state :idling
-
-    MachineWithStaticInitialStateTest.const_set('Vehicle', @model)
-
-    driver_model = new_model(:driver) do
-      connection.add_column table_name, :vehicle_id, :integer
-
-      belongs_to :vehicle, :class_name => 'MachineWithStaticInitialStateTest::Vehicle'
-    end
-
-    MachineWithStaticInitialStateTest.const_set('Driver', driver_model)
-
-    record = @model.create(:state => 'idling')
-    driver = driver_model.create(:vehicle_id => record.id)
-    assert_equal 'idling', driver.vehicle.state
-  end
-
-  def teardown
-    MachineWithStaticInitialStateTest.class_eval do
-      remove_const('Vehicle') if defined?(MachineWithStaticInitialStateTest::Vehicle)
-      remove_const('Owner') if defined?(MachineWithStaticInitialStateTest::Owner)
-      remove_const('Driver') if defined?(MachineWithStaticInitialStateTest::Driver)
-    end
-
-    clear_active_support_dependencies
-    super
-  end
-end
-

data/test/machine_with_transactions_test.rb

@@ -1,26 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithTransactionsTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :use_transactions => true)
-  end
-
-  def test_should_rollback_transaction_if_false
-    @machine.within_transaction(@model.new) do
-      @model.create
-      false
-    end
-
-    assert_equal 0, @model.count
-  end
-
-  def test_should_not_rollback_transaction_if_true
-    @machine.within_transaction(@model.new) do
-      @model.create
-      true
-    end
-
-    assert_equal 1, @model.count
-  end
-end

data/test/machine_with_validations_and_custom_attribute_test.rb

@@ -1,21 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :status, :attribute => :state)
-    @machine.state :parked
-
-    @record = @model.new
-  end
-
-  def test_should_add_validation_errors_to_custom_attribute
-    @record.state = 'invalid'
-
-    refute @record.valid?
-    assert_equal ['State is invalid'], @record.errors.full_messages
-
-    @record.state = 'parked'
-    assert @record.valid?
-  end
-end

data/test/machine_with_validations_test.rb

@@ -1,47 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithValidationsTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked
-
-    @record = @model.new
-  end
-
-  def test_should_invalidate_using_errors
-    I18n.backend = I18n::Backend::Simple.new
-    @record.state = 'parked'
-
-    @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
-    assert_equal ['State cannot transition via "park"'], @record.errors.full_messages
-  end
-
-  def test_should_auto_prefix_custom_attributes_on_invalidation
-    @machine.invalidate(@record, :event, :invalid)
-
-    assert_equal ['State event is invalid'], @record.errors.full_messages
-  end
-
-  def test_should_clear_errors_on_reset
-    @record.state = 'parked'
-    @record.errors.add(:state, 'is invalid')
-
-    @machine.reset(@record)
-    assert_equal [], @record.errors.full_messages
-  end
-
-  def test_should_be_valid_if_state_is_known
-    @record.state = 'parked'
-
-    assert @record.valid?
-  end
-
-  def test_should_not_be_valid_if_state_is_unknown
-    @record.state = 'invalid'
-
-    refute @record.valid?
-    assert_equal ['State is invalid'], @record.errors.full_messages
-  end
-end
-

data/test/machine_without_database_test.rb

@@ -1,20 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithoutDatabaseTest < BaseTestCase
-  def setup
-    @model = new_model(false) do
-      # Simulate the database not being available entirely
-      def self.connection
-        raise ActiveRecord::ConnectionNotEstablished
-      end
-
-      def self.connected?
-        false
-      end
-    end
-  end
-
-  def test_should_allow_machine_creation
-    assert_nothing_raised { StateMachines::Machine.new(@model) }
-  end
-end

data/test/machine_without_transactions_test.rb

@@ -1,26 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithoutTransactionsTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :use_transactions => false)
-  end
-
-  def test_should_not_rollback_transaction_if_false
-    @machine.within_transaction(@model.new) do
-      @model.create
-      false
-    end
-
-    assert_equal 1, @model.count
-  end
-
-  def test_should_not_rollback_transaction_if_true
-    @machine.within_transaction(@model.new) do
-      @model.create
-      true
-    end
-
-    assert_equal 1, @model.count
-  end
-end

data/test/model_test.rb

@@ -1,12 +0,0 @@
-require_relative 'test_helper'
-require_relative 'files/models/post'
-
-class ModelTest < ActiveSupport::TestCase
-  def test_should_have_draft_state_in_defaut_machine
-    assert_equal 'draft', Post.new.state
-  end
-
-  def test_should_have_the_correct_integration
-    assert_equal StateMachines::Integrations::ActiveRecord, StateMachines::Integrations.match(Post)
-  end
-end

data/test/test_helper.rb

@@ -1,58 +0,0 @@
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
-require 'minitest/reporters'
-Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
-require 'state_machines-activerecord'
-require 'minitest/autorun'
-require 'securerandom'
-
-# Establish database connection
-ActiveRecord::Base.establish_connection('adapter' => 'sqlite3', 'database' => ':memory:')
-ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/../log/active_record.log")
-ActiveSupport.test_order = :random
-
-class BaseTestCase < ActiveSupport::TestCase
-  protected
-  # Creates a new ActiveRecord model (and the associated table)
-  def new_model(create_table = :foo, &block)
-    name = create_table || :foo
-    table_name = "#{name}_#{SecureRandom.hex(6)}"
-
-    model = Class.new(ActiveRecord::Base) do
-      self.table_name = table_name.to_s
-      connection.create_table(table_name, :force => true) { |t| t.string(:state) } if create_table
-
-      define_method(:abort_from_callback) do
-        throw :abort
-      end
-
-      (
-      class << self;
-        self;
-      end).class_eval do
-        define_method(:name) { "#{name.to_s.capitalize}" }
-      end
-    end
-    model.class_eval(&block) if block_given?
-    model.reset_column_information if create_table
-    model
-  end
-
-  def clear_active_support_dependencies
-    return unless defined?(ActiveSupport::Dependencies)
-
-    if ActiveSupport::Dependencies.respond_to?(:autoloader=)
-      ActiveSupport::Dependencies.autoloader ||= stubbed_autoloader
-    end
-
-    ActiveSupport::Dependencies.clear
-  end
-
-  def stubbed_autoloader
-    Object.new.tap do |obj|
-      obj.define_singleton_method(:reload) {}
-    end
-  end
-end