database_cleaner 0.8.0 → 0.9.1

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

@@ -0,0 +1,40 @@
+shared_examples_for "an adapter with pre-count truncation" do
+  describe "#pre_count_truncate_tables" do
+    
+    context "with :reset_ids set true" do
+      it "truncates the table" do
+        2.times { User.create }
+
+        connection.pre_count_truncate_tables(%w[users], :reset_ids => true)
+        User.count.should be_zero
+      end
+
+      it "resets AUTO_INCREMENT index of table" do
+        2.times { User.create }
+        User.delete_all
+
+        connection.pre_count_truncate_tables(%w[users]) # true is also the default
+        User.create.id.should == 1
+      end
+    end
+
+    
+    context "with :reset_ids set false" do
+      it "truncates the table" do
+        2.times { User.create }
+
+        connection.pre_count_truncate_tables(%w[users], :reset_ids => false)
+        User.count.should be_zero
+      end
+
+      it "does not reset AUTO_INCREMENT index of table" do
+        2.times { User.create }
+        User.delete_all
+
+        connection.pre_count_truncate_tables(%w[users], :reset_ids => false)
+
+        User.create.id.should == 3
+      end
+    end
+  end
+end

data/spec/database_cleaner/active_record/truncation_spec.rb

@@ -1,16 +1,15 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'active_record'
-require 'database_cleaner/active_record/truncation'
 
+require 'database_cleaner/active_record/truncation'
 
 module ActiveRecord
   module ConnectionAdapters
     [MysqlAdapter, Mysql2Adapter, SQLite3Adapter, JdbcAdapter, PostgreSQLAdapter, IBM_DBAdapter].each do |adapter|
       describe adapter, "#truncate_table" do
         it "responds" do
-          adapter.new("foo").should respond_to(:truncate_table)
+          adapter.instance_methods.should include('truncate_table')
         end
-        it "should truncate the table"
       end
     end
   end
@@ -22,55 +21,125 @@ module DatabaseCleaner
     describe Truncation do
       let(:connection) { mock('connection') }
 
-
       before(:each) do
         connection.stub!(:disable_referential_integrity).and_yield
-        connection.stub!(:views).and_return([])
+        connection.stub!(:database_cleaner_view_cache).and_return([])
         ::ActiveRecord::Base.stub!(:connection).and_return(connection)
       end
 
-      it "should truncate all tables except for schema_migrations" do
-        connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
-        
-        connection.should_receive(:truncate_tables).with(['widgets', 'dogs'])
-        Truncation.new.clean
-      end
+      describe '#clean' do
+        it "should truncate all tables except for schema_migrations" do
+          connection.stub!(:database_cleaner_table_cache).and_return(%w[schema_migrations widgets dogs])
 
-      it "should only truncate the tables specified in the :only option when provided" do
-        connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+          connection.should_receive(:truncate_tables).with(['widgets', 'dogs'])
+          Truncation.new.clean
+        end
 
-        connection.should_receive(:truncate_tables).with(['widgets'])
+        it "should only truncate the tables specified in the :only option when provided" do
+          connection.stub!(:database_cleaner_table_cache).and_return(%w[schema_migrations widgets dogs])
 
-        Truncation.new(:only => ['widgets']).clean
-      end
+          connection.should_receive(:truncate_tables).with(['widgets'])
 
-      it "should not truncate the tables specified in the :except option" do
-        connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+          Truncation.new(:only => ['widgets']).clean
+        end
 
-        connection.should_receive(:truncate_tables).with(['dogs'])
+        it "should not truncate the tables specified in the :except option" do
+          connection.stub!(:database_cleaner_table_cache).and_return(%w[schema_migrations widgets dogs])
 
-        Truncation.new(:except => ['widgets']).clean
-      end
+          connection.should_receive(:truncate_tables).with(['dogs'])
 
-      it "should raise an error when :only and :except options are used" do
-        running {
-          Truncation.new(:except => ['widgets'], :only => ['widgets'])
-        }.should raise_error(ArgumentError)
-      end
+          Truncation.new(:except => ['widgets']).clean
+        end
+
+        it "should raise an error when :only and :except options are used" do
+          running {
+            Truncation.new(:except => ['widgets'], :only => ['widgets'])
+          }.should raise_error(ArgumentError)
+        end
+
+        it "should raise an error when invalid options are provided" do
+          running { Truncation.new(:foo => 'bar') }.should raise_error(ArgumentError)
+        end
+
+        it "should not truncate views" do
+          connection.stub!(:database_cleaner_table_cache).and_return(%w[widgets dogs])
+          connection.stub!(:database_cleaner_view_cache).and_return(["widgets"])
+
+          connection.should_receive(:truncate_tables).with(['dogs'])
+
+          Truncation.new.clean
+        end
 
-      it "should raise an error when invalid options are provided" do
-        running { Truncation.new(:foo => 'bar') }.should raise_error(ArgumentError)
+        describe "relying on #pre_count_truncate_tables if connection allows it" do
+          subject { Truncation.new }
+
+          it "should rely on #pre_count_truncate_tables if #pre_count? returns true" do
+            connection.stub!(:database_cleaner_table_cache).and_return(%w[widgets dogs])
+            connection.stub!(:database_cleaner_view_cache).and_return(["widgets"])
+
+            subject.instance_variable_set(:"@pre_count", true)
+
+            connection.should_not_receive(:truncate_tables).with(['dogs'])
+            connection.should_receive(:pre_count_truncate_tables).with(['dogs'], :reset_ids => true)
+
+            subject.clean
+          end
+
+          it "should not rely on #pre_count_truncate_tables if #pre_count? return false" do
+            connection.stub!(:database_cleaner_table_cache).and_return(%w[widgets dogs])
+            connection.stub!(:database_cleaner_view_cache).and_return(["widgets"])
+
+            subject.instance_variable_set(:"@pre_count", false)
+
+            connection.should_not_receive(:pre_count_truncate_tables).with(['dogs'], :reset_ids => true)
+            connection.should_receive(:truncate_tables).with(['dogs'])
+
+            subject.clean
+          end
+        end
       end
 
-      it "should not truncate views" do
-        connection.stub!(:tables).and_return(%w[widgets dogs])
-        connection.stub!(:views).and_return(["widgets"])
+      describe '#pre_count?' do
+        before(:each) do
+          connection.stub!(:disable_referential_integrity).and_yield
+          connection.stub!(:database_cleaner_view_cache).and_return([])
+          ::ActiveRecord::Base.stub!(:connection).and_return(connection)
+        end
 
-        connection.should_receive(:truncate_tables).with(['dogs'])
+        subject { Truncation.new }
+        its(:pre_count?) { should == false }
 
-        Truncation.new.clean
+        it 'should return true if @reset_id is set and non false or nil' do
+          subject.instance_variable_set(:"@pre_count", true)
+          subject.send(:pre_count?).should == true
+        end
+
+        it 'should return false if @reset_id is set to false' do
+          subject.instance_variable_set(:"@pre_count", false)
+          subject.send(:pre_count?).should == false
+        end
       end
+      
+      describe '#reset_ids?' do
+        before(:each) do
+          connection.stub!(:disable_referential_integrity).and_yield
+          connection.stub!(:database_cleaner_view_cache).and_return([])
+          ::ActiveRecord::Base.stub!(:connection).and_return(connection)
+        end
+        
+        subject { Truncation.new }
+        its(:reset_ids?) { should == true }
 
+        it 'should return true if @reset_id is set and non false or nil' do
+          subject.instance_variable_set(:"@reset_ids", 'Something')
+          subject.send(:reset_ids?).should == true
+        end
+
+        it 'should return false if @reset_id is set to false' do
+          subject.instance_variable_set(:"@reset_ids", false)
+          subject.send(:reset_ids?).should == false
+        end
+      end
     end
   end
 end

data/spec/database_cleaner/base_spec.rb

@@ -274,10 +274,10 @@ module DatabaseCleaner
     end
 
     describe "create_strategy" do
-      let(:klass) { mock("klass",:new => mock("instance")) }
+      let(:strategy_class) { mock("strategy_class",:new => mock("instance")) }
 
       before :each do
-        subject.stub(:orm_strategy).and_return(klass)
+        subject.stub(:orm_strategy).and_return(strategy_class)
       end
 
       it "should pass the first argument to orm_strategy" do
@@ -285,12 +285,12 @@ module DatabaseCleaner
         subject.create_strategy :strategy
       end
       it "should pass the remainding argument to orm_strategy.new" do
-        klass.should_receive(:new).with(:params => {:lorum => "ipsum"})
+        strategy_class.should_receive(:new).with(:params => {:lorum => "ipsum"})
 
         subject.create_strategy :strategy, {:params => {:lorum => "ipsum"}}
       end
       it "should return the resulting strategy" do
-        subject.create_strategy( :strategy ).should == klass.new
+        subject.create_strategy( :strategy ).should == strategy_class.new
       end
     end
 
@@ -415,10 +415,10 @@ module DatabaseCleaner
     end
 
     describe "orm_strategy" do
-      let (:klass) { mock("klass") }
+      let (:strategy_class) { mock("strategy_class") }
 
       before(:each) do
-        subject.stub(:orm_module).and_return(klass)
+        subject.stub(:orm_module).and_return(strategy_class)
       end
 
       context "in response to a LoadError" do
@@ -433,31 +433,31 @@ module DatabaseCleaner
         end
 
         it "should ask orm_module if it will list available_strategies" do
-          klass.should_receive(:respond_to?).with(:available_strategies)
+          strategy_class.should_receive(:respond_to?).with(:available_strategies)
 
-          subject.stub(:orm_module).and_return(klass)
+          subject.stub(:orm_module).and_return(strategy_class)
 
           expect { subject.send(:orm_strategy,:a_strategy) }.to raise_error UnknownStrategySpecified
         end
 
         it "should use available_strategies (for the error message) if its available" do
-          klass.stub(:respond_to?).with(:available_strategies).and_return(true)
-          klass.should_receive(:available_strategies).and_return([])
+          strategy_class.stub(:respond_to?).with(:available_strategies).and_return(true)
+          strategy_class.should_receive(:available_strategies).and_return([])
 
-          subject.stub(:orm_module).and_return(klass)
+          subject.stub(:orm_module).and_return(strategy_class)
 
           expect { subject.send(:orm_strategy,:a_strategy) }.to raise_error UnknownStrategySpecified
         end
       end
 
       it "should return the constant of the Strategy class requested" do
-        strategy_klass = mock("strategy klass")
+        strategy_strategy_class = mock("strategy strategy_class")
 
         subject.stub(:require).with(anything).and_return(true)
 
-        klass.should_receive(:const_get).with("Cunningplan").and_return(strategy_klass)
+        strategy_class.should_receive(:const_get).with("Cunningplan").and_return(strategy_strategy_class)
 
-        subject.send(:orm_strategy, :cunningplan).should == strategy_klass
+        subject.send(:orm_strategy, :cunningplan).should == strategy_strategy_class
       end
 
     end

data/spec/database_cleaner/configuration_spec.rb

@@ -1,12 +1,20 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
+module ArrayHelper
+  def zipmap(array, vals)
+    Hash[*(array.zip(vals).flatten)]
+  end
+  module_function :zipmap
+end
 
 module DatabaseCleaner
   class << self
     def reset
+      @cleaners = nil
       @connections = nil
     end
-
+    # hackey, hack.. connections needs to stick around until I can properly deprecate the API
     def connections_stub!(array)
+      @cleaners = ArrayHelper.zipmap((1..array.size).to_a, array)
       @connections = array
     end
   end
@@ -17,7 +25,7 @@ describe ::DatabaseCleaner do
 
   context "orm specification" do
     it "should not accept unrecognised orms" do
-      expect { ::DatabaseCleaner[nil] }.should raise_error(::DatabaseCleaner::NoORMDetected)
+      expect { ::DatabaseCleaner[nil] }.to raise_error(::DatabaseCleaner::NoORMDetected)
     end
 
     it "should accept :active_record" do
@@ -108,14 +116,11 @@ describe ::DatabaseCleaner do
   context "class methods" do
     subject { ::DatabaseCleaner }
 
-    its(:connections) { should respond_to(:each) }
-
     it "should give me a default (autodetection) databasecleaner by default" do
       cleaner = mock("cleaner").as_null_object
-      ::DatabaseCleaner::Base.should_receive(:new).with().and_return(cleaner)
-
-      ::DatabaseCleaner.connections.should have(1).items
-      ::DatabaseCleaner.connections.first.should == cleaner
+      ::DatabaseCleaner::Base.stub!(:new).and_return(cleaner)
+      
+      ::DatabaseCleaner.connections.should == [cleaner]
     end
   end
 
@@ -197,7 +202,7 @@ describe ::DatabaseCleaner do
     # plausably want to force orm/strategy change on two sets of orm that differ only on db
     context "multiple orm proxy methods" do
 
-      it "should proxy orm to all connections and remove duplicate connections" do
+      pending "should proxy orm to all connections and remove duplicate connections" do
         active_record_1 = mock("active_mock_on_db_one").as_null_object
         active_record_2 = mock("active_mock_on_db_two").as_null_object
         data_mapper_1   = mock("data_mock_on_db_one").as_null_object

data/spec/database_cleaner/data_mapper/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'database_cleaner/data_mapper/base'
-require 'database_cleaner/shared_strategy_spec'
+require 'database_cleaner/shared_strategy'
 
 module DatabaseCleaner
   describe DataMapper do

data/spec/database_cleaner/data_mapper/transaction_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'database_cleaner/data_mapper/transaction'
-require 'database_cleaner/shared_strategy_spec'
+require 'database_cleaner/shared_strategy'
 #require 'data_mapper'
 
 module DatabaseCleaner

data/spec/database_cleaner/data_mapper/truncation_spec.rb

@@ -1,5 +1,5 @@
 require 'database_cleaner/data_mapper/truncation'
-require 'database_cleaner/shared_strategy_spec'
+require 'database_cleaner/shared_strategy'
 
 module DatabaseCleaner
   module DataMapper

data/spec/database_cleaner/generic/base_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'database_cleaner/shared_strategy_spec'
+require 'database_cleaner/shared_strategy'
 require 'database_cleaner/generic/base'
 
 module ::DatabaseCleaner

data/spec/database_cleaner/generic/truncation_spec.rb

@@ -13,11 +13,19 @@ module ::DatabaseCleaner
       def except
         @tables_to_exclude
       end
+
+      def reset_ids?
+        !!@reset_ids
+      end
+
+      def pre_count?
+        !!@pre_count
+      end
     end
 
     class MigrationExample < TruncationExample
-      def migration_storage_name
-        "migration_storage_name"
+      def migration_storage_names
+        %w[migration_storage_name]
       end
     end
 
@@ -29,8 +37,8 @@ module ::DatabaseCleaner
         it { should_not respond_to(:tables_to_truncate) }
         its(:tables_to_truncate) { expect{ subject }.to raise_error(NotImplementedError) }
 
-        it { should_not respond_to(:migration_storage_name) }
-        its(:migration_storage_name) { should be_nil }
+        it { should_not respond_to(:migration_storage_names) }
+        its(:migration_storage_names) { should be_empty }
       end
 
       describe "initialize" do
@@ -44,6 +52,8 @@ module ::DatabaseCleaner
         it { expect{ TruncationExample.new( { :except => "something",:only => "something else" } ) }.to     raise_error(ArgumentError) }
         it { expect{ TruncationExample.new( { :only   => "something"                           } ) }.to_not raise_error(ArgumentError) }
         it { expect{ TruncationExample.new( { :except => "something"                           } ) }.to_not raise_error(ArgumentError) }
+        it { expect{ TruncationExample.new( { :pre_count => "something"                           } ) }.to_not raise_error(ArgumentError) }
+        it { expect{ TruncationExample.new( { :reset_ids => "something"                           } ) }.to_not raise_error(ArgumentError) }
 
         context "" do
           subject { TruncationExample.new( { :only => ["something"] } ) }
@@ -57,10 +67,30 @@ module ::DatabaseCleaner
           its(:except) { should include("something") }
         end
 
+        context "" do
+          subject { TruncationExample.new( { :reset_ids => ["something"] } ) }
+          its(:reset_ids?) { should == true }
+        end
+
+        context "" do
+          subject { TruncationExample.new( { :reset_ids => nil } ) }
+          its(:reset_ids?) { should == false }
+        end
+
+        context "" do
+          subject { TruncationExample.new( { :pre_count => ["something"] } ) }
+          its(:pre_count?) { should == true }
+        end
+
+        context "" do
+          subject { TruncationExample.new( { :pre_count => nil } ) }
+          its(:pre_count?) { should == false }
+        end
+
         context "" do
           subject { MigrationExample.new }
           its(:only)   { should == nil }
-          its(:except) { should == ["migration_storage_name"] }
+          its(:except) { should == %w[migration_storage_name] }
         end
 
         context "" do