Don't skip tests if we don't need to.

We can conditional define the tests depending on the adapter or
connection.

Lets keep the skip for fail tests that need to be fixed.

1 files changed, 72 insertions, 80 deletions

diff --git a/activerecord/test/cases/transaction_isolation_test.rb b/activerecord/test/cases/transaction_isolation_test.rb
index 4f1cb99b68..84c16fb109 100644
--- a/activerecord/test/cases/transaction_isolation_test.rb
+++ b/activerecord/test/cases/transaction_isolation_test.rb
@@ -1,113 +1,105 @@
 require 'cases/helper'
 
-class TransactionIsolationUnsupportedTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+unless ActiveRecord::Base.connection.supports_transaction_isolation?
+  class TransactionIsolationUnsupportedTest < ActiveRecord::TestCase
+    self.use_transactional_fixtures = false
 
-  class Tag < ActiveRecord::Base
-  end
-
-  setup do
-    if ActiveRecord::Base.connection.supports_transaction_isolation?
-      skip "database supports transaction isolation; test is irrelevant"
+    class Tag < ActiveRecord::Base
     end
-  end
 
-  test "setting the isolation level raises an error" do
-    assert_raises(ActiveRecord::TransactionIsolationError) do
-      Tag.transaction(isolation: :serializable) { }
+    test "setting the isolation level raises an error" do
+      assert_raises(ActiveRecord::TransactionIsolationError) do
+        Tag.transaction(isolation: :serializable) { }
+      end
     end
   end
 end
 
-class TransactionIsolationTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-
-  class Tag < ActiveRecord::Base
-    self.table_name = 'tags'
-  end
-
-  class Tag2 < ActiveRecord::Base
-    self.table_name = 'tags'
-  end
+if ActiveRecord::Base.connection.supports_transaction_isolation?
+  class TransactionIsolationTest < ActiveRecord::TestCase
+    self.use_transactional_fixtures = false
 
-  setup do
-    unless ActiveRecord::Base.connection.supports_transaction_isolation?
-      skip "database does not support setting transaction isolation"
+    class Tag < ActiveRecord::Base
+      self.table_name = 'tags'
     end
 
-    Tag.establish_connection 'arunit'
-    Tag2.establish_connection 'arunit'
-    Tag.destroy_all
-  end
-
-  # It is impossible to properly test read uncommitted. The SQL standard only
-  # specifies what must not happen at a certain level, not what must happen. At
-  # the read uncommitted level, there is nothing that must not happen.
-  test "read uncommitted" do
-    unless ActiveRecord::Base.connection.transaction_isolation_levels.include?(:read_uncommitted)
-      skip "database does not support read uncommitted isolation level"
+    class Tag2 < ActiveRecord::Base
+      self.table_name = 'tags'
     end
-    Tag.transaction(isolation: :read_uncommitted) do
-      assert_equal 0, Tag.count
-      Tag2.create
-      assert_equal 1, Tag.count
+
+    setup do
+      Tag.establish_connection 'arunit'
+      Tag2.establish_connection 'arunit'
+      Tag.destroy_all
     end
-  end
 
-  # We are testing that a dirty read does not happen
-  test "read committed" do
-    Tag.transaction(isolation: :read_committed) do
-      assert_equal 0, Tag.count
+    # It is impossible to properly test read uncommitted. The SQL standard only
+    # specifies what must not happen at a certain level, not what must happen. At
+    # the read uncommitted level, there is nothing that must not happen.
+    if ActiveRecord::Base.connection.transaction_isolation_levels.include?(:read_uncommitted)
+      test "read uncommitted" do
+        Tag.transaction(isolation: :read_uncommitted) do
+          assert_equal 0, Tag.count
+          Tag2.create
+          assert_equal 1, Tag.count
+        end
+      end
+    end
 
-      Tag2.transaction do
-        Tag2.create
+    # We are testing that a dirty read does not happen
+    test "read committed" do
+      Tag.transaction(isolation: :read_committed) do
         assert_equal 0, Tag.count
+
+        Tag2.transaction do
+          Tag2.create
+          assert_equal 0, Tag.count
+        end
       end
+
+      assert_equal 1, Tag.count
     end
 
-    assert_equal 1, Tag.count
-  end
+    # We are testing that a nonrepeatable read does not happen
+    if ActiveRecord::Base.connection.transaction_isolation_levels.include?(:repeatable_read)
+      test "repeatable read" do
+        tag = Tag.create(name: 'jon')
 
-  # We are testing that a nonrepeatable read does not happen
-  test "repeatable read" do
-    unless ActiveRecord::Base.connection.transaction_isolation_levels.include?(:repeatable_read)
-      skip "database does not support repeatable read isolation level"
-    end
-    tag = Tag.create(name: 'jon')
+        Tag.transaction(isolation: :repeatable_read) do
+          tag.reload
+          Tag2.find(tag.id).update(name: 'emily')
 
-    Tag.transaction(isolation: :repeatable_read) do
-      tag.reload
-      Tag2.find(tag.id).update(name: 'emily')
+          tag.reload
+          assert_equal 'jon', tag.name
+        end
 
-      tag.reload
-      assert_equal 'jon', tag.name
+        tag.reload
+        assert_equal 'emily', tag.name
+      end
     end
 
-    tag.reload
-    assert_equal 'emily', tag.name
-  end
-
-  # We are only testing that there are no errors because it's too hard to
-  # test serializable. Databases behave differently to enforce the serializability
-  # constraint.
-  test "serializable" do
-    Tag.transaction(isolation: :serializable) do
-      Tag.create
+    # We are only testing that there are no errors because it's too hard to
+    # test serializable. Databases behave differently to enforce the serializability
+    # constraint.
+    test "serializable" do
+      Tag.transaction(isolation: :serializable) do
+        Tag.create
+      end
     end
-  end
 
-  test "setting isolation when joining a transaction raises an error" do
-    Tag.transaction do
-      assert_raises(ActiveRecord::TransactionIsolationError) do
-        Tag.transaction(isolation: :serializable) { }
+    test "setting isolation when joining a transaction raises an error" do
+      Tag.transaction do
+        assert_raises(ActiveRecord::TransactionIsolationError) do
+          Tag.transaction(isolation: :serializable) { }
+        end
       end
     end
-  end
 
-  test "setting isolation when starting a nested transaction raises error" do
-    Tag.transaction do
-      assert_raises(ActiveRecord::TransactionIsolationError) do
-        Tag.transaction(requires_new: true, isolation: :serializable) { }
+    test "setting isolation when starting a nested transaction raises error" do
+      Tag.transaction do
+        assert_raises(ActiveRecord::TransactionIsolationError) do
+          Tag.transaction(requires_new: true, isolation: :serializable) { }
+        end
       end
     end
   end