database_cleaner 1.6.2 → 1.7.0

data/features/support/env.rb

@@ -1,4 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'database_cleaner'
-
-require 'rspec/expectations'

data/features/support/feature_runner.rb

@@ -1,39 +0,0 @@
-class FeatureRunner
-  attr_accessor :orm
-  attr_accessor :another_orm
-  attr_accessor :multiple_databases
-  attr_accessor :strategy
-  attr_accessor :exit_status
-  attr_accessor :output
-
-  def strategy
-    @strategy || 'truncation'
-  end
-
-  def go(feature)
-    full_dir ||= File.expand_path(File.dirname(__FILE__) + "/../../examples/")
-    Dir.chdir(full_dir) do
-
-
-      ENV['ORM']          = orm
-      ENV['STRATEGY']     = strategy
-
-      if another_orm
-       ENV['ANOTHER_ORM']  = another_orm
-      else
-        ENV['ANOTHER_ORM'] = nil
-      end
-
-      if multiple_databases
-        ENV['MULTIPLE_DBS'] = "true"
-      else
-        ENV['MULTIPLE_DBS'] = nil
-      end
-
-      self.output = `#{"jruby -S " if defined?(JRUBY_VERSION)}cucumber features/#{feature}.feature`
-
-      self.exit_status = $?.exitstatus
-    end
-  end
-
-end

data/spec/database_cleaner/active_record/base_spec.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/shared_strategy'
-
-class FakeModel
-  def self.connection
-    :fake_connection
-  end
-end
-
-module DatabaseCleaner
-  describe ActiveRecord do
-    it { should respond_to(:available_strategies) }
-
-    describe "config_file_location" do
-      subject { ActiveRecord.config_file_location }
-
-      it "should default to DatabaseCleaner.root / config / database.yml" do
-        ActiveRecord.config_file_location=nil
-        DatabaseCleaner.should_receive(:app_root).and_return("/path/to")
-        subject.should eq '/path/to/config/database.yml'
-      end
-    end
-
-  end
-
-  module ActiveRecord
-    class ExampleStrategy
-      include ::DatabaseCleaner::ActiveRecord::Base
-    end
-
-    describe ExampleStrategy do
-      let :config_location do
-        '/path/to/config/database.yml'
-      end
-
-      before { ::DatabaseCleaner::ActiveRecord.stub(:config_file_location).and_return(config_location) }
-
-      it_should_behave_like "a generic strategy"
-
-      describe "db" do
-
-        it "should store my desired db" do
-          subject.stub(:load_config)
-
-          subject.db = :my_db
-          subject.db.should eq :my_db
-        end
-
-        it "should default to :default" do
-          subject.db.should eq :default
-        end
-
-        it "should load_config when I set db" do
-          subject.should_receive(:load_config)
-          subject.db = :my_db
-        end
-      end
-
-      describe "load_config" do
-
-        before do
-          subject.db = :my_db
-          yaml       = <<-Y
-my_db:
-  database: <%= "ONE".downcase %>
-          Y
-          File.stub(:file?).with(config_location).and_return(true)
-          IO.stub(:read).with(config_location).and_return(yaml)
-        end
-
-        it "should parse the config" do
-          YAML.should_receive(:load).and_return({ :nil => nil })
-          subject.load_config
-        end
-
-        it "should process erb in the config" do
-          transformed = <<-Y
-my_db:
-  database: one
-          Y
-          YAML.should_receive(:load).with(transformed).and_return({ "my_db" => { "database" => "one" } })
-          subject.load_config
-        end
-
-        context 'use ActiveRecord::Base.configuration' do
-          it 'when config file different with it' do
-            ::ActiveRecord::Base.stub(:configurations).and_return({ "my_db" =>{ "database" => "two"} })
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "two"})
-          end
-        end
-
-        context 'use config file' do
-          it 'when config file same with it' do
-            ::ActiveRecord::Base.stub(:configurations).and_return({ "my_db" =>{ "database" => "one"} })
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "one"})
-          end
-
-          it 'when ::ActiveRecord::Base.configurations nil' do
-            ::ActiveRecord::Base.stub(:configurations).and_return(nil)
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "one"})
-          end
-
-          it 'when ::ActiveRecord::Base.configurations empty' do
-            ::ActiveRecord::Base.stub(:configurations).and_return({})
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "one"})
-          end
-        end
-
-        it "should store the relevant config in connection_hash" do
-          subject.load_config
-          subject.connection_hash.should eq( "database" => "one" )
-        end
-
-        it "should skip config if config file is not available" do
-          File.should_receive(:file?).with(config_location).and_return(false)
-          subject.load_config
-          subject.connection_hash.should_not be
-        end
-
-        it "skips the file when the model is set" do
-          subject.db = FakeModel
-          YAML.should_not_receive(:load)
-          subject.load_config
-          subject.connection_hash.should_not 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
-          YAML.should_not_receive(:load)
-          subject.load_config
-          subject.connection_hash.should_not be
-        end
-
-      end
-
-      describe "connection_hash" do
-        it "should store connection_hash" do
-          subject.connection_hash = { :key => "value" }
-          subject.connection_hash.should eq( :key => "value" )
-        end
-      end
-
-      describe "connection_class" do
-        it { expect { subject.connection_class }.to_not raise_error }
-        it "should default to ActiveRecord::Base" do
-          subject.connection_class.should eq ::ActiveRecord::Base
-        end
-
-        context "with database models" do
-          context "connection_hash is set" do
-            it "allows for database models to be passed in" do
-              subject.db = FakeModel
-              subject.connection_hash = { }
-              subject.load_config
-              subject.connection_class.should eq FakeModel
-            end
-          end
-
-          context "connection_hash is not set" do
-            it "allows for database models to be passed in" do
-              subject.db = FakeModel
-              subject.connection_class.should eq FakeModel
-            end
-          end
-        end
-
-        context "when connection_hash is set" do
-          let(:hash) { double("hash") }
-          before { ::ActiveRecord::Base.stub(:respond_to?).and_return(false) }
-          before { subject.stub(:connection_hash).and_return(hash) }
-
-          it "establish a connection using ActiveRecord::Base" do
-            ::ActiveRecord::Base.should_receive(:establish_connection).with(hash)
-
-            subject.connection_class
-          end
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/active_record/transaction_spec.rb

@@ -1,176 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'database_cleaner/active_record/transaction'
-require 'active_record'
-
-module DatabaseCleaner
-  module ActiveRecord
-
-    describe Transaction do
-      let (:connection) { double("connection") }
-      let (:connection_2) { double("connection") }
-      let (:connection_pool) { double("connection_pool")}
-      before(:each) do
-        ::ActiveRecord::Base.stub(:connection_pool).and_return(connection_pool)
-        connection_pool.stub(:connections).and_return([connection])
-        ::ActiveRecord::Base.stub(: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
-              connection.stub(:transaction)
-              connection.stub(begin_transaction_method)
-              connection.stub(:respond_to?).with(:begin_transaction).and_return(:begin_transaction == begin_transaction_method)
-            end
-
-            it "should increment open transactions if possible" do
-              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(true)
-              connection.should_receive(:increment_open_transactions)
-              Transaction.new.start
-            end
-
-            it "should tell ActiveRecord to increment connection if its not possible to increment current connection" do
-              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(false)
-              ::ActiveRecord::Base.should_receive(:increment_open_transactions)
-              Transaction.new.start
-            end
-
-            it "should start a transaction" do
-              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(true)
-              connection.stub(:increment_open_transactions)
-              connection.should_receive(begin_transaction_method)
-              connection.should_receive(:transaction)
-              Transaction.new.start
-            end
-          end
-        end
-      end
-
-      describe "#clean" do
-        context "manual accounting of transaction count" do
-          it "should start a transaction" do
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.stub(:decrement_open_transactions)
-
-            connection.should_receive(:rollback_db_transaction)
-            Transaction.new.clean
-          end
-
-          it "should decrement open transactions if possible" do
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(true)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            connection.should_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-
-          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
-            connection.should_receive(:open_transactions).and_return(0)
-
-            Transaction.new.clean
-          end
-
-          it "should decrement connection via ActiveRecord::Base if connection won't" do
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-
-          it "should rollback open transactions in all connections" do
-            connection_pool.stub(:connections).and_return([connection, connection_2])
-
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            connection_2.should_receive(:open_transactions).and_return(1)
-            connection_2.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection_2.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection_2.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection_2.stub(:rollback_db_transaction)
-
-            ::ActiveRecord::Base.should_receive(:decrement_open_transactions).twice
-            Transaction.new.clean
-          end
-
-          it "should rollback open transactions in all connections with an open transaction" do
-            connection_pool.stub(:connections).and_return([connection, connection_2])
-
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            connection_2.should_receive(:open_transactions).and_return(0)
-
-            ::ActiveRecord::Base.should_receive(:decrement_open_transactions).exactly(1).times
-            Transaction.new.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
-            connection.stub(:rollback_db_transaction)
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.should_not_receive(:decrement_open_transactions)
-            connection.should_receive(:rollback_transaction)
-            Transaction.new.clean
-          end
-
-          it "should decrement open transactions if possible" do
-            connection.stub(:rollback_transaction)
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.should_not_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-
-          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
-            connection.should_receive(:open_transactions).and_return(0)
-
-            Transaction.new.clean
-          end
-
-          it "should decrement connection via ActiveRecord::Base if connection won't" do
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(true)
-            connection.stub(:rollback_transaction)
-
-            ::ActiveRecord::Base.should_not_receive(:decrement_open_transactions)
-            Transaction.new.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)
-          Transaction.new.connection_maintains_transaction_count?.should be_true
-        end
-        it "should return false if the major active record version is > 3" do
-          stub_const("ActiveRecord::VERSION::MAJOR", 4)
-          Transaction.new.connection_maintains_transaction_count?.should be_false
-        end
-      end
-
-    end
-  end
-end

data/spec/database_cleaner/active_record/truncation/mysql2_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'support/active_record/mysql2_setup'
-require 'database_cleaner/active_record/truncation'
-require 'database_cleaner/active_record/truncation/shared_fast_truncation'
-
-module ActiveRecord
-  module ConnectionAdapters
-    describe do
-      before(:all) { active_record_mysql2_setup }
-
-      let(:connection) { active_record_mysql2_connection }
-
-      describe "#truncate_table" do
-        it "should truncate the table" do
-          2.times { User.create }
-
-          connection.truncate_table('users')
-          User.count.should eq 0
-        end
-
-        it "should reset AUTO_INCREMENT index of table" do
-          2.times { User.create }
-          User.delete_all
-
-          connection.truncate_table('users')
-
-          User.create.id.should eq 1
-        end
-      end
-
-      it_behaves_like "an adapter with pre-count truncation" do
-        let(:connection) { active_record_mysql2_connection }
-      end
-    end
-  end
-end
-