Support transactions

[tfausak]

http://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html

Specifically look at wrapping execute in a transaction by default with an option to disable it.

[tfausak]

We'd have to add a dependency on ActiveRecord to do this. Looks like it'd be pretty straightforward, though:

require 'active_record'
module ActiveInteraction
  class Base
    def self.run(options = {})
      new(options).tap do |interaction|
        if interaction.valid?
          result = nil
          ::ActiveRecord::Base.transaction do
            result = interaction.execute
          end
          interaction.instance_variable_set(:@result, result)
        end
      end
    end
  end
end

Testing it would be a little difficult.

[tfausak]

I just want to reiterate that testing this is a pain in the ass. The implementation is a piece of cake:

module ActiveInteraction
  class Base
    begin
      require 'active_record'
      def self.transaction
        ::ActiveRecord::Base.transaction do
          yield
        end
      end
    rescue LoadError
      def self.transaction
        yield
      end
    end
    private_class_method :transaction

    def self.run(options = {})
      new(options).tap do |interaction|
        if interaction.valid?
          result = transaction { interaction.execute }
          interaction.instance_variable_set(:@result, result)
        end
      end
    end
  end
end

It's simple enough that I wouldn't feel bad about shipping it without tests, but that feels dirty. I just can't think of a clean way to set up a test that:

1. Runs with and without transactions enabled. In other words, with ActiveRecord, then without it.
2. Sets up a database connection and a model and saves instances of the model to the database. This is probably the least challenging part, but it's still worth mentioning.
3. Checks nested transactions.

On top of all that, ActiveRecord should be disabled for the rest of the test suite because it'll slow it down somewhat.