get rspec tests running in ar adapter gem.

Author: botandrose-machine

.gitignore

@@ -7,8 +7,9 @@ bundled_gems/
 vendor/
 examples/db/*.db
 examples/config/database.yml
-db/config.yml
-db/test.sqlite3
+spec/support/config.yml
+tmp/*
+!tmp/.keep
 .rbenv-version
 .rvmrc
 .ruby-version

CONTRIBUTE.markdown

@@ -11,8 +11,7 @@ upstream:
 ## 2. Make sure the tests run fine
 
 - `bundle install`
-- Copy `db/sample.config.yml` to `db/config.yml` and edit it
-- Make sure to create the databases specified in `db/config.yml`
+- Copy `spec/support/sample.config.yml` to `spec/support/config.yml` and edit it
 - Run the tests with `bundle exec rspec`
 
 Note that if you don't have all the supported databases installed and running,

Gemfile.lock

@@ -1,12 +1,14 @@
 PATH
-  remote: adapters
+  remote: .
   specs:
-    database_cleaner-active_record (0.1.0)
+    database_cleaner (1.8.0)
 
 PATH
-  remote: .
+  remote: adapters
   specs:
-    database_cleaner (1.7.0)
+    database_cleaner-active_record (0.1.0)
+      activerecord
+      database_cleaner (~> 1.8.0)
 
 GEM
   remote: https://rubygems.org/

adapters/database_cleaner-active_record/.gitignore

@@ -5,7 +5,9 @@
 /doc/
 /pkg/
 /spec/reports/
+/spec/support/config.yml
 /tmp/
+!/tmp/.keep
 
 # rspec failure tracking
 .rspec_status

adapters/database_cleaner-active_record/lib/database_cleaner/active_record.rb

@@ -1,3 +1,4 @@
+require 'database_cleaner/active_record/version'
 require 'database_cleaner'
 require 'database_cleaner/active_record/deletion'
 require 'database_cleaner/active_record/transaction'

adapters/database_cleaner-active_record/spec/database_cleaner/active_record/base_spec.rb

@@ -0,0 +1,166 @@
+require 'active_record'
+require 'database_cleaner/active_record/base'
+require 'database_cleaner/spec'
+
+class FakeModel
+  def self.connection
+    :fake_connection
+  end
+end
+
+RSpec.describe DatabaseCleaner::ActiveRecord do
+  it { is_expected.to respond_to(:available_strategies) }
+
+  describe "config_file_location" do
+    after do
+      # prevent global state leakage
+      DatabaseCleaner::ActiveRecord.config_file_location=nil
+      DatabaseCleaner.app_root = nil
+    end
+
+    it "should default to \#{DatabaseCleaner.app_root}/config/database.yml" do
+      DatabaseCleaner::ActiveRecord.config_file_location = nil
+      DatabaseCleaner.app_root = "/path/to"
+      expect(DatabaseCleaner::ActiveRecord.config_file_location).to eq '/path/to/config/database.yml'
+    end
+  end
+end
+
+module DatabaseCleaner
+  module ActiveRecord
+    class ExampleStrategy
+      include DatabaseCleaner::ActiveRecord::Base
+    end
+
+    RSpec.describe ExampleStrategy do
+      let(:config_location) { '/path/to/config/database.yml' }
+
+      around do |example|
+        DatabaseCleaner::ActiveRecord.config_file_location = config_location
+        example.run
+        DatabaseCleaner::ActiveRecord.config_file_location = nil
+      end
+
+      it_should_behave_like "a generic strategy"
+
+      describe "db" do
+        it "should store my desired db" do
+          subject.db = :my_db
+          expect(subject.db).to eq :my_db
+        end
+
+        it "should default to :default" do
+          expect(subject.db).to eq :default
+        end
+      end
+
+      describe "db=" do
+        let(:config_location) { "spec/support/example.database.yml" }
+
+        it "should process erb in the config" do
+          subject.db = :my_db
+          expect(subject.connection_hash).to eq({ "database" => "one" })
+        end
+
+        context 'when config file differs from established ActiveRecord configuration' do
+          before do
+            allow(::ActiveRecord::Base).to receive(:configurations).and_return({ "my_db" => { "database" => "two"} })
+          end
+
+          it 'uses the ActiveRecord configuration' do
+            subject.db = :my_db
+            expect(subject.connection_hash).to eq({ "database" => "two"})
+          end
+        end
+
+        context 'when config file agrees with ActiveRecord configuration' do
+          before do
+            allow(::ActiveRecord::Base).to receive(:configurations).and_return({ "my_db" => { "database" => "one"} })
+          end
+
+          it 'uses the config file' do
+            subject.db = :my_db
+            expect(subject.connection_hash).to eq({ "database" => "one"})
+          end
+        end
+
+        context 'when ::ActiveRecord::Base.configurations nil' do
+          before do
+            allow(::ActiveRecord::Base).to receive(:configurations).and_return(nil)
+          end
+
+          it 'uses the config file' do
+            subject.db = :my_db
+            expect(subject.connection_hash).to eq({ "database" => "one"})
+          end
+        end
+
+        context 'when ::ActiveRecord::Base.configurations empty' do
+          before do
+            allow(::ActiveRecord::Base).to receive(:configurations).and_return({})
+          end
+
+          it 'uses the config file' do
+            subject.db = :my_db
+            expect(subject.connection_hash).to eq({ "database" => "one"})
+          end
+        end
+
+        context 'when config file is not available' do
+          before do
+            allow(File).to receive(:file?).with(config_location).and_return(false)
+          end
+
+          it "should skip config" do
+            subject.db = :my_db
+            expect(subject.connection_hash).not_to be
+          end
+        end
+
+        it "skips the file when the model is set" do
+          subject.db = FakeModel
+          expect(subject.connection_hash).not_to be
+        end
+
+        it "skips the file when the db is set to :default" do
+          # to avoid https://github.com/bmabey/database_cleaner/issues/72
+          subject.db = :default
+          expect(subject.connection_hash).not_to be
+        end
+      end
+
+      describe "connection_class" do
+        it "should default to ActiveRecord::Base" do
+          expect(subject.connection_class).to eq ::ActiveRecord::Base
+        end
+
+        context "with database models" do
+          context "connection_hash is set" do
+            it "reuses the model's connection" do
+              subject.connection_hash = {}
+              subject.db = FakeModel
+              expect(subject.connection_class).to eq FakeModel
+            end
+          end
+
+          context "connection_hash is not set" do
+            it "reuses the model's connection" do
+              subject.db = FakeModel
+              expect(subject.connection_class).to eq FakeModel
+            end
+          end
+        end
+
+        context "when connection_hash is set" do
+          let(:hash) { {} }
+          before { subject.connection_hash = hash }
+
+          it "establishes a connection with it" do
+            expect(::ActiveRecord::Base).to receive(:establish_connection).with(hash)
+            expect(subject.connection_class).to eq ::ActiveRecord::Base
+          end
+        end
+      end
+    end
+  end
+end

adapters/database_cleaner-active_record/spec/database_cleaner/active_record/transaction_spec.rb

@@ -0,0 +1,155 @@
+require 'database_cleaner/active_record/transaction'
+require 'active_record'
+
+module DatabaseCleaner
+  module ActiveRecord
+
+    RSpec.describe Transaction do
+      let(:connection) { double("connection") }
+      let(:connection_2) { double("connection_2") }
+      let(:connection_pool) { double("connection_pool") }
+
+      before do
+        allow(::ActiveRecord::Base).to receive(:connection_pool).and_return(connection_pool)
+        allow(connection_pool).to receive(:connections).and_return([connection])
+        allow(::ActiveRecord::Base).to receive(:connection).and_return(connection)
+      end
+
+      describe "#start" do
+        [:begin_transaction, :begin_db_transaction].each do |begin_transaction_method|
+          context "using #{begin_transaction_method}" do
+            before do
+              allow(connection).to receive(:transaction)
+              allow(connection).to receive(begin_transaction_method)
+            end
+
+            it "should increment open transactions if possible" do
+              expect(connection).to receive(:increment_open_transactions)
+              subject.start
+            end
+
+            it "should tell ActiveRecord to increment connection if its not possible to increment current connection" do
+              expect(::ActiveRecord::Base).to receive(:increment_open_transactions)
+              subject.start
+            end
+
+            it "should start a transaction" do
+              allow(connection).to receive(:increment_open_transactions)
+              expect(connection).to receive(begin_transaction_method)
+              expect(connection).to receive(:transaction)
+              subject.start
+            end
+          end
+        end
+      end
+
+      describe "#clean" do
+        context "manual accounting of transaction count" do
+          it "should start a transaction" do
+            expect(connection).to receive(:open_transactions).and_return(1)
+
+            allow(connection).to receive(:decrement_open_transactions)
+
+            expect(connection).to receive(:rollback_db_transaction)
+            subject.clean
+          end
+
+          it "should decrement open transactions if possible" do
+            expect(connection).to receive(:open_transactions).and_return(1)
+
+            allow(connection).to receive(:rollback_db_transaction)
+
+            expect(connection).to receive(:decrement_open_transactions)
+            subject.clean
+          end
+
+          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
+            expect(connection).to receive(:open_transactions).and_return(0)
+
+            subject.clean
+          end
+
+          it "should decrement connection via ActiveRecord::Base if connection won't" do
+            expect(connection).to receive(:open_transactions).and_return(1)
+            allow(connection).to receive(:rollback_db_transaction)
+
+            expect(::ActiveRecord::Base).to receive(:decrement_open_transactions)
+            subject.clean
+          end
+
+          it "should rollback open transactions in all connections" do
+            allow(connection_pool).to receive(:connections).and_return([connection, connection_2])
+
+            expect(connection).to receive(:open_transactions).and_return(1)
+            allow(connection).to receive(:rollback_db_transaction)
+
+            expect(connection_2).to receive(:open_transactions).and_return(1)
+            allow(connection_2).to receive(:rollback_db_transaction)
+
+            expect(::ActiveRecord::Base).to receive(:decrement_open_transactions).twice
+            subject.clean
+          end
+
+          it "should rollback open transactions in all connections with an open transaction" do
+            allow(connection_pool).to receive(:connections).and_return([connection, connection_2])
+
+            expect(connection).to receive(:open_transactions).and_return(1)
+            allow(connection).to receive(:rollback_db_transaction)
+
+            expect(connection_2).to receive(:open_transactions).and_return(0)
+
+            expect(::ActiveRecord::Base).to receive(:decrement_open_transactions).exactly(1).times
+            subject.clean
+          end
+        end
+
+        context "automatic accounting of transaction count (AR 4)" do
+          before { stub_const("ActiveRecord::VERSION::MAJOR", 4) }
+
+          it "should start a transaction" do
+            allow(connection).to receive(:rollback_db_transaction)
+            expect(connection).to receive(:open_transactions).and_return(1)
+
+            expect(connection).not_to receive(:decrement_open_transactions)
+            expect(connection).to receive(:rollback_transaction)
+            subject.clean
+          end
+
+          it "should decrement open transactions if possible" do
+            allow(connection).to receive(:rollback_transaction)
+            expect(connection).to receive(:open_transactions).and_return(1)
+
+            expect(connection).not_to receive(:decrement_open_transactions)
+            subject.clean
+          end
+
+          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
+            expect(connection).to receive(:open_transactions).and_return(0)
+
+            subject.clean
+          end
+
+          it "should decrement connection via ActiveRecord::Base if connection won't" do
+            expect(connection).to receive(:open_transactions).and_return(1)
+            allow(connection).to receive(:rollback_transaction)
+
+            expect(::ActiveRecord::Base).not_to receive(:decrement_open_transactions)
+            subject.clean
+          end
+        end
+      end
+
+      describe "#connection_maintains_transaction_count?" do
+        it "should return true if the major active record version is < 4" do
+          stub_const("ActiveRecord::VERSION::MAJOR", 3)
+          expect(subject.connection_maintains_transaction_count?).to be_truthy
+        end
+
+        it "should return false if the major active record version is > 3" do
+          stub_const("ActiveRecord::VERSION::MAJOR", 4)
+          expect(subject.connection_maintains_transaction_count?).to be_falsey
+        end
+      end
+    end
+  end
+end