transaction_isolation 1.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+

data/Gemfile

@@ -0,0 +1,24 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in kontolib.gemspec
+gemspec
+
+group :test do
+  # Use the gem instead of a dated version bundled with Ruby
+  gem 'minitest', '2.8.1'
+
+  gem 'activerecord', "3.1.3"
+  
+  gem 'simplecov', :require => false
+
+  gem 'mysql2'
+  gem 'pg'
+  gem 'sqlite3'
+end
+
+group :development do
+  gem 'rake'
+  # enhance irb
+  gem 'awesome_print', :require => false
+  gem 'pry', :require => false
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Piotr 'Qertoip' Włodarek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# transaction_isolation
+
+Adds support for setting transaction isolation level in ActiveRecord in a database agnostic way.
+
+## Example
+
+    ActiveRecord::Base.isolation_level( :serializable ) do
+      # your code
+    end
+
+## Installation
+
+Add this to your Gemfile:
+
+    gem 'transaction_isolation'
+
+Then run:
+
+    bundle
+
+## Features
+
+ * Setting transaction isolation level (:read_uncommitted, :read_committed, :repeatable_read, :serializable)
+ * Auto-reverting to the original isolation level after the block
+ * Database agnostic
+ * MySQL2, PostgreSQL and SQLite3 database connection adapters supported
+ * Exception translation. All deadlocks and serialization errors are wrapped in a ActiveRecord::TransactionIsolationConflict exception
+ * Use it in your Rails application or a standalone ActiveRecord-based project
+
+## Real world example
+
+When implementing a table-based job queue you should ensure that only one worker process can pop a particular job from the queue.
+Wrapping your code in a transaction is not enough because by default databases do not isolate transactions to the full extent,
+which leads to occasional phantom reads. It is therefore necessary to manually raise the transaction isolation level.
+The highest level of transaction isolation is called "serializable".
+
+[Read about isolation levels in Wikipedia](http://tinyurl.com/nrqjbb)
+
+    class QueuedJob < ActiveRecord::Base
+
+      # Job status
+      TODO = 1
+      PROCESSING = 2
+      DONE = 3
+
+      # Returns first job from the queue or nil if the queue is empty
+      def pop
+        QueuedJob.isolation_level( :serializable ) do
+          QueuedJob.transaction do
+            queued_job = find_by_status( TODO )
+            if queud_job
+              queued_job.update_attribute( :status, PROCESSING )
+              return queued_job
+            else
+              return nil
+            end
+          end
+        end
+      end
+
+    end
+
+## Requirements
+
+ * Ruby 1.9
+ * ActiveRecord 3.1+
+
+## Running tests
+
+Run tests on the selected database (mysql2 by default):
+
+    db=mysql2 bundle exec rake test
+    db=postgresql bundle exec rake test
+    db=sqlite3 bundle exec rake test
+
+Run tests on all supported databases:
+
+    ./tests
+
+Database configuration is hardcoded in test/db/db.rb; feel free to improve this and submit a pull request.
+
+## How intrusive is this gem?
+
+You should be very suspicious about any gem that monkey patches your stock Ruby on Rails framework.
+
+This gem is carefully written to not be more intrusive than it needs to be:
+
+ * introduces several new methods to Mysql2Adapter, PostgreSQLAdapter, SQLite3Adapter; names are carefully taken to not collide with future changes
+ * wraps #translate_exception method using alias_method_chain to add new translation
+ * introduces new class ActiveRecord::TransactionIsolationConflict in the ActiveRecord module
+ * introduces new convenience method ActiveRecord::Base.isolation_level akin to ActiveRecord::Base.transaction
+
+## License
+
+Released under the MIT license. Copyright (C) 2012 Piotr 'Qertoip' Włodarek.

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs += ["test", "lib"]
+  t.pattern = 'test/integration/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => [:test]

data/d

@@ -0,0 +1 @@
+bundle exec ruby test/test_console.rb

data/lib/transaction_isolation.rb

@@ -0,0 +1,30 @@
+require_relative 'transaction_isolation/version'
+
+module TransactionIsolation
+
+  # Must be called after ActiveRecord established a connection.
+  # Only then we know which connection adapter is actually loaded and can be enhanced.
+  # Please note ActiveRecord does not load unused adapters.
+  def self.apply_activerecord_patch
+    require_relative 'transaction_isolation/active_record/errors'
+    require_relative 'transaction_isolation/active_record/base'
+    require_relative 'transaction_isolation/active_record/connection_adapters/abstract_adapter'
+    require_relative 'transaction_isolation/active_record/connection_adapters/mysql2_adapter'
+    require_relative 'transaction_isolation/active_record/connection_adapters/postgresql_adapter'
+    require_relative 'transaction_isolation/active_record/connection_adapters/sqlite3_adapter'
+  end
+
+  if defined?( ::Rails )
+    # Setup applying the patch after Rails is initialized.
+    class Railtie < ::Rails::Railtie
+      config.after_initialize do
+        TransactionIsolation.apply_activerecord_patch
+      end
+    end
+  else
+    # Without Rails we can apply the patch outright. It is programmer responsibility
+    # to require the transaction_isolation gem *after* connecting to the database.
+    TransactionIsolation.apply_activerecord_patch
+  end
+  
+end

data/lib/transaction_isolation/active_record/base.rb

@@ -0,0 +1,13 @@
+require 'active_record/base'
+
+module TransactionIsolation
+  module ActiveRecord
+    module Base
+      def isolation_level( isolation_level, &block )
+        connection.isolation_level( isolation_level, &block )
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend( TransactionIsolation::ActiveRecord::Base )

data/lib/transaction_isolation/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,32 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+module TransactionIsolation
+  module ActiveRecord
+    module ConnectionAdapters # :nodoc:
+      module AbstractAdapter
+
+        VALID_ISOLATION_LEVELS = [:read_uncommitted, :read_committed, :repeatable_read, :serializable]
+
+        # If true, #isolation_level(level) method is available
+        def supports_isolation_levels?
+          false
+        end
+
+        def isolation_level( level )
+          raise NotImplementedError
+        end
+
+        private
+
+          def validate_isolation_level( isolation_level )
+            unless VALID_ISOLATION_LEVELS.include?( isolation_level )
+              raise ArgumentError, "Invalid isolation level '#{isolation_level}'. Supported levels include #{VALID_ISOLATION_LEVELS.join( ', ' )}."
+            end
+          end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::AbstractAdapter )

data/lib/transaction_isolation/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,77 @@
+if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+
+  module TransactionIsolation
+    module ActiveRecord
+      module ConnectionAdapters # :nodoc:
+        module Mysql2Adapter
+
+          def self.included( base )
+            base.class_eval do
+              alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
+              alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
+            end
+          end
+          
+          def supports_isolation_levels?
+            true
+          end
+
+          VENDOR_ISOLATION_LEVEL = {
+              :read_uncommitted => 'READ UNCOMMITTED',
+              :read_committed => 'READ COMMITTED',
+              :repeatable_read => 'REPEATABLE READ',
+              :serializable => 'SERIALIZABLE'
+          }
+
+          ANSI_ISOLATION_LEVEL = {
+              'READ UNCOMMITTED' => :read_uncommitted,
+              'READ COMMITTED' => :read_committed,
+              'REPEATABLE READ' => :repeatable_read,
+              'SERIALIZABLE' => :serializable
+          }
+          
+          def current_isolation_level
+            ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
+          end
+          
+          def current_vendor_isolation_level
+            select_value( "SELECT @@session.tx_isolation" ).gsub( '-', ' ' )
+          end
+          
+          def isolation_level( level )
+            validate_isolation_level( level )
+            
+            original_vendor_isolation_level = current_vendor_isolation_level if block_given?
+            
+            execute( "SET SESSION TRANSACTION ISOLATION LEVEL #{VENDOR_ISOLATION_LEVEL[level]}" )
+            
+            begin
+              yield
+            ensure
+              execute "SET SESSION TRANSACTION ISOLATION LEVEL #{original_vendor_isolation_level}"
+            end if block_given?
+          end
+
+          def translate_exception_with_transaction_isolation_conflict( exception, message )
+            if isolation_conflict?( exception )
+              ::ActiveRecord::TransactionIsolationConflict.new( "Transaction isolation conflict detected: #{exception.message}", exception )
+            else
+              translate_exception_without_transaction_isolation_conflict( exception, message )
+            end
+          end
+          
+          def isolation_conflict?( exception )
+            [ "Deadlock found when trying to get lock",
+              "Lock wait timeout exceeded"].any? do |error_message|
+              exception.message =~ /#{Regexp.escape( error_message )}/i
+            end
+          end
+
+        end
+      end
+    end
+  end
+
+  ActiveRecord::ConnectionAdapters::Mysql2Adapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+
+end

data/lib/transaction_isolation/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,77 @@
+if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+
+  module TransactionIsolation
+    module ActiveRecord
+      module ConnectionAdapters # :nodoc:
+        module PostgreSQLAdapter
+
+          def self.included( base )
+            base.class_eval do
+              alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
+              alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
+            end
+          end
+                    
+          def supports_isolation_levels?
+            true
+          end
+          
+          VENDOR_ISOLATION_LEVEL = {
+              :read_uncommitted => 'READ UNCOMMITTED',
+              :read_committed => 'READ COMMITTED',
+              :repeatable_read => 'REPEATABLE READ',
+              :serializable => 'SERIALIZABLE'
+          }
+
+          ANSI_ISOLATION_LEVEL = {
+              'READ UNCOMMITTED' => :read_uncommitted,
+              'READ COMMITTED' => :read_committed,
+              'REPEATABLE READ' => :repeatable_read,
+              'SERIALIZABLE' => :serializable
+          }
+          
+          def current_isolation_level
+            ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
+          end
+
+          def current_vendor_isolation_level
+            select_value( "SHOW TRANSACTION ISOLATION LEVEL" ).upcase
+          end
+
+          def isolation_level( level )
+            validate_isolation_level( level )
+
+            original_vendor_isolation_level = current_vendor_isolation_level if block_given?
+            
+            execute "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL #{VENDOR_ISOLATION_LEVEL[level]}"
+            
+            begin
+              yield
+            ensure
+              execute "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL #{original_vendor_isolation_level}"
+            end if block_given?
+          end
+
+          def translate_exception_with_transaction_isolation_conflict( exception, message )
+            if isolation_conflict?( exception )
+              ::ActiveRecord::TransactionIsolationConflict.new( "Transaction isolation conflict detected: #{exception.message}", exception )
+            else
+              translate_exception_without_transaction_isolation_conflict( exception, message )
+            end
+          end
+          
+          def isolation_conflict?( exception )
+            [ "deadlock detected",
+              "could not serialize access" ].any? do |error_message|
+              exception.message =~ /#{Regexp.escape( error_message )}/i
+            end
+          end
+
+        end
+      end
+    end
+  end
+
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+
+end

data/lib/transaction_isolation/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,76 @@
+if defined?( ActiveRecord::ConnectionAdapters::SQLiteAdapter )
+
+  module TransactionIsolation
+    module ActiveRecord
+      module ConnectionAdapters # :nodoc:
+        module SQLite3Adapter
+
+          def self.included( base )
+            base.class_eval do
+              alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
+              alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
+            end
+          end
+
+          def supports_isolation_levels?
+            true
+          end
+
+          VENDOR_ISOLATION_LEVEL = {
+              :read_uncommitted => 'read_uncommitted = 1',
+              :read_committed => 'read_uncommitted = 0',
+              :repeatable_read => 'read_uncommitted = 0',
+              :serializable => 'read_uncommitted = 0'
+          }
+          
+          ANSI_ISOLATION_LEVEL = {
+              'read_uncommitted = 1' => :read_uncommitted,
+              'read_uncommitted = 0' => :serializable
+          }
+          
+          def current_isolation_level
+            ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
+          end
+
+          def current_vendor_isolation_level
+            "read_uncommitted = #{select_value( "PRAGMA read_uncommitted" )}"
+          end
+          
+          def isolation_level( level )
+            validate_isolation_level( level )
+
+            original_vendor_isolation_level = current_vendor_isolation_level if block_given?
+            
+            execute "PRAGMA #{VENDOR_ISOLATION_LEVEL[level]}"
+
+            begin
+              yield
+            ensure
+              execute "PRAGMA #{original_vendor_isolation_level}"
+            end if block_given?
+          end
+          
+          def translate_exception_with_transaction_isolation_conflict( exception, message )
+            if isolation_conflict?( exception )
+              ::ActiveRecord::TransactionIsolationConflict.new( "Transaction isolation conflict detected: #{exception.message}", exception )
+            else
+              translate_exception_without_transaction_isolation_conflict( exception, message )
+            end
+          end
+          
+          # http://www.sqlite.org/c3ref/c_abort.html
+          def isolation_conflict?( exception )
+            [ "The database file is locked",
+              "A table in the database is locked",
+              "Database lock protocol error"].any? do |error_message|
+              exception.message =~ /#{Regexp.escape( error_message )}/i
+            end
+          end
+        end
+      end
+    end
+  end
+
+  ActiveRecord::ConnectionAdapters::SQLite3Adapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+
+end

data/lib/transaction_isolation/active_record/errors.rb

@@ -0,0 +1,10 @@
+require 'active_record/errors'
+
+module ActiveRecord
+  # This exception represents both deadlocks and serialization conflicts.
+  # Deadlocks happen when db engine is using lock-based concurrency control.
+  # Serialization conflicts happen when db engine is using multi-version concurrency control.
+  # Often db engines combine both approaches and thus generate both types of errors.
+
+  class TransactionIsolationConflict < ::ActiveRecord::WrappedDatabaseException; end
+end

data/lib/transaction_isolation/version.rb

@@ -0,0 +1,3 @@
+module TransactionIsolation
+  VERSION = "1.0.1"
+end

data/test/db/all.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require_relative 'db'
+require_relative 'migrations'
+require_relative 'queued_job'

data/test/db/db.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module TransactionIsolation
+  module Test
+    module Db
+
+      def self.connect_to_mysql2
+        ::ActiveRecord::Base.establish_connection(
+          :adapter => "mysql2",
+          :database => "transaction_isolation_test", #database_filepath
+          :user => 'root',
+          :password => ''
+        )
+      end
+      
+      def self.connect_to_postgresql
+        ::ActiveRecord::Base.establish_connection(
+          :adapter => "postgresql",
+          :database => "transaction_isolation_test", #database_filepath
+          :user => 'qertoip',
+          :password => 'test123'
+        )
+      end
+      
+      def self.connect_to_sqlite3
+        ActiveRecord::Base.establish_connection(
+          :adapter => "sqlite3",
+          :database => ":memory:",
+          :verbosity => "silent"
+        )
+      end
+
+    end
+  end
+end

data/test/db/migrations.rb

@@ -0,0 +1,20 @@
+module TransactionIsolation
+  module Test
+    module Migrations
+
+      def self.run!
+        c = ::ActiveRecord::Base.connection
+
+        # Queued Jobs
+        
+        c.create_table "queued_jobs", :force => true do |t|
+          t.text     "job",                               :null => false
+          t.integer  "status",     :default => 0,         :null => false
+          t.timestamps
+        end
+
+      end
+
+    end
+  end
+end

data/test/db/queued_job.rb

@@ -0,0 +1,2 @@
+class QueuedJob < ActiveRecord::Base
+end

data/test/integration/active_record/base/isolation_level_test.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < MiniTest::Unit::TestCase
+
+  class BaseTest < MiniTest::Unit::TestCase
+
+    class IsolationLevelTest < MiniTest::Unit::TestCase
+
+      def test_wraps_connection_isolation_level
+        ActiveRecord::Base.isolation_level( :serializable ) do
+          ActiveRecord::Base.transaction do
+            assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/current_isolation_level_test.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < MiniTest::Unit::TestCase
+
+  class ConnectionAdaptersTest < MiniTest::Unit::TestCase
+
+    class AnyAdapterTest < MiniTest::Unit::TestCase
+
+      class CurrentIsolationLevelTest < MiniTest::Unit::TestCase
+
+        def test_returns_correct_default_isolation_level
+          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+            assert_equal( :repeatable_read, ActiveRecord::Base.connection.current_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+            assert_equal( :read_committed, ActiveRecord::Base.connection.current_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+            assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/current_vendor_isolation_level_test.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < MiniTest::Unit::TestCase
+
+  class ConnectionAdaptersTest < MiniTest::Unit::TestCase
+
+    class AnyAdapterTest < MiniTest::Unit::TestCase
+
+      class CurrentVendorIsolationLevelTest < MiniTest::Unit::TestCase
+
+        def test_returns_correct_default_vendor_isolation_level
+          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+            assert_equal( 'REPEATABLE READ', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+            assert_equal( 'READ COMMITTED', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+            assert_equal( 'read_uncommitted = 0', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/isolation_level_test.rb

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < MiniTest::Unit::TestCase
+
+  class ConnectionAdaptersTest < MiniTest::Unit::TestCase
+
+    class AnyAdapterTest < MiniTest::Unit::TestCase
+
+      class IsolationLevelTest < MiniTest::Unit::TestCase
+
+        def test_without_a_block
+          original_isolation_level = ActiveRecord::Base.connection.current_isolation_level
+
+          ActiveRecord::Base.connection.isolation_level( :read_uncommitted )
+          assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+
+          ActiveRecord::Base.connection.isolation_level( original_isolation_level )
+          assert_equal( original_isolation_level, ActiveRecord::Base.connection.current_isolation_level )
+        end
+
+        def test_with_a_block
+          original_isolation_level = ActiveRecord::Base.connection.current_isolation_level
+          refute_equal( :read_uncommitted, original_isolation_level )
+
+          ActiveRecord::Base.connection.isolation_level( :read_uncommitted ) do
+            assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+            ActiveRecord::Base.transaction do
+              assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+              QueuedJob.count
+              QueuedJob.first
+              assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+            end
+            assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+          end
+
+          assert_equal( original_isolation_level, ActiveRecord::Base.connection.current_isolation_level )
+        end
+
+        def test_with_all_possible_ansi_levels
+          [:read_uncommitted, :read_committed, :repeatable_read, :serializable].each do |ansi_level|
+
+            QueuedJob.isolation_level( ansi_level ) do
+
+              # Some typical usage
+              QueuedJob.transaction do
+                QueuedJob.create!( :job => 'is fun' )
+                assert_equal( 1, QueuedJob.count )
+                raise ActiveRecord::Rollback
+              end
+
+            end
+          end
+        end
+
+        def test_with_invalid_isolation_level
+          assert_raises( ArgumentError ) do
+            QueuedJob.isolation_level( :dupa )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/supports_isolation_levels_test.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < MiniTest::Unit::TestCase
+
+  class ConnectionAdaptersTest < MiniTest::Unit::TestCase
+
+    class AnyAdapterTest < MiniTest::Unit::TestCase
+
+      class SupportsIsolationLevelsTest < MiniTest::Unit::TestCase
+
+        def test_returns_true
+          assert( ActiveRecord::Base.connection.supports_isolation_levels? )
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/translate_exception_test.rb

@@ -0,0 +1,52 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < MiniTest::Unit::TestCase
+
+  class ConnectionAdaptersTest < MiniTest::Unit::TestCase
+
+    class AnyAdapterTest < MiniTest::Unit::TestCase
+
+      class TranslateExceptionTest < MiniTest::Unit::TestCase
+
+        def test_does_not_break_existing_translation
+          assert_raises( ActiveRecord::StatementInvalid ) do
+            ActiveRecord::Base.connection.execute( "WE LIVE IN THE MOST EXCITING TIMES EVER" )
+          end
+        end
+
+        def test_translates_low_level_exceptions_to_transaction_isolation_level
+          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+            message = "Deadlock found when trying to get lock"
+            translated_exception = ActiveRecord::Base.connection.send( :translate_exception, Mysql2::Error.new( message ), message )
+            assert_equal( ActiveRecord::TransactionIsolationConflict, translated_exception.class )
+          end
+          
+          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+            message = "deadlock detected"
+            translated_exception = ActiveRecord::Base.connection.send( :translate_exception, PGError.new( message ), message )
+            assert_equal( ActiveRecord::TransactionIsolationConflict, translated_exception.class )
+          end
+          
+          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+            message = "The database file is locked"
+            translated_exception = ActiveRecord::Base.connection.send( :translate_exception, StandardError.new( message ), message )
+            assert_equal( ActiveRecord::TransactionIsolationConflict, translated_exception.class )
+          end
+          
+          #  assert_equal( :read_committed, ActiveRecord::Base.connection.current_isolation_level )
+          #end
+          #
+          #if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+          #  assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
+          #end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/library_setup.rb

@@ -0,0 +1,20 @@
+# Prepares application to be tested (requires files, connects to db, resets schema and data, applies patches, etc.)
+
+# Initialize database
+require 'db/all'
+
+case ENV['db']
+  when 'mysql2'
+    TransactionIsolation::Test::Db.connect_to_mysql2
+  when 'postgresql'
+    TransactionIsolation::Test::Db.connect_to_postgresql
+  when 'sqlite3'
+    TransactionIsolation::Test::Db.connect_to_sqlite3
+  else
+    TransactionIsolation::Test::Db.connect_to_mysql2
+end
+
+TransactionIsolation::Test::Migrations.run!
+
+# Load the code that will be tested
+require 'transaction_isolation'

data/test/test_console.rb

@@ -0,0 +1,11 @@
+# Ensure that LOAD_PATH is the same as when running "rake test"; normally rake takes care of that
+$LOAD_PATH << File.expand_path( ".", File.dirname( __FILE__ ) )
+$LOAD_PATH << File.expand_path( "./lib", File.dirname( __FILE__ ) )
+$LOAD_PATH << File.expand_path( "./test", File.dirname( __FILE__ ) )
+
+# Boot the app
+require_relative 'library_setup'
+
+# Fire the console
+require 'pry'
+binding.pry

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+# Load test coverage tool (must be loaded before any code)
+#require 'simplecov'
+#SimpleCov.start do
+#  add_filter '/test/'
+#  add_filter '/config/'
+#end
+
+# Load and initialize the application to be tested
+require 'library_setup'
+
+# Load test frameworks
+require 'minitest/autorun'

data/test/test_runner.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+# Load all tests
+Dir.glob( "./**/*_test.rb" ).each { |test_file| require test_file }

data/tests

@@ -0,0 +1,6 @@
+
+db=mysql2 bundle exec rake
+
+db=postgresql bundle exec rake
+
+db=sqlite3 bundle exec rake

data/transaction-isolation.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "transaction_isolation/version"
+
+Gem::Specification.new do |s|
+  s.name        = "transaction_isolation"
+  s.version     = TransactionIsolation::VERSION
+  s.authors     = ["Piotr 'Qertoip' Włodarek"]
+  s.email       = ["qertoip@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Adds support for setting transaction isolation level in ActiveRecord in a database agnostic way.}
+  s.description = %q{Run transactions with a serializable / repeatable read / read committed / read uncommitted isolation level in MySQL2, PostgreSQL and SQLite3}
+  
+  s.rubyforge_project = "transaction_isolation"
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "activerecord"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: transaction_isolation
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Piotr 'Qertoip' Włodarek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &16117860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16117860
+description: Run transactions with a serializable / repeatable read / read committed
+  / read uncommitted isolation level in MySQL2, PostgreSQL and SQLite3
+email:
+- qertoip@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- d
+- lib/transaction_isolation.rb
+- lib/transaction_isolation/active_record/base.rb
+- lib/transaction_isolation/active_record/connection_adapters/abstract_adapter.rb
+- lib/transaction_isolation/active_record/connection_adapters/mysql2_adapter.rb
+- lib/transaction_isolation/active_record/connection_adapters/postgresql_adapter.rb
+- lib/transaction_isolation/active_record/connection_adapters/sqlite3_adapter.rb
+- lib/transaction_isolation/active_record/errors.rb
+- lib/transaction_isolation/version.rb
+- test/db/all.rb
+- test/db/db.rb
+- test/db/migrations.rb
+- test/db/queued_job.rb
+- test/integration/active_record/base/isolation_level_test.rb
+- test/integration/active_record/connection_adapters/any_adapter/current_isolation_level_test.rb
+- test/integration/active_record/connection_adapters/any_adapter/current_vendor_isolation_level_test.rb
+- test/integration/active_record/connection_adapters/any_adapter/isolation_level_test.rb
+- test/integration/active_record/connection_adapters/any_adapter/supports_isolation_levels_test.rb
+- test/integration/active_record/connection_adapters/any_adapter/translate_exception_test.rb
+- test/library_setup.rb
+- test/log/.gitkeep
+- test/test_console.rb
+- test/test_helper.rb
+- test/test_runner.rb
+- tests
+- transaction-isolation.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1075603796640971358
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1075603796640971358
+requirements: []
+rubyforge_project: transaction_isolation
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Adds support for setting transaction isolation level in ActiveRecord in a
+  database agnostic way.
+test_files: []