jonrowe-database_cleaner 0.5.2

data/lib/database_cleaner/mongo_mapper/truncation.rb

@@ -0,0 +1,30 @@
+require 'database_cleaner/truncation_base'
+
+module DatabaseCleaner
+  module MongoMapper
+    class Truncation < DatabaseCleaner::TruncationBase
+      def clean
+        if @only
+          collections.each { |c| c.remove if @only.include?(c.name) }
+        else
+          collections.each { |c| c.remove unless @tables_to_exclude.include?(c.name) }
+        end
+        true
+      end
+
+      private
+
+      def connection
+        ::MongoMapper.connection
+      end
+
+      def collections
+        connection.db(database).collections
+      end
+
+      def database
+        ::MongoMapper.database.name
+      end
+    end
+  end
+end

data/lib/database_cleaner/truncation_base.rb

@@ -0,0 +1,41 @@
+module DatabaseCleaner
+  class TruncationBase
+
+    def initialize(options = {})
+      if !options.empty? && !(options.keys - [:only, :except]).empty?
+        raise ArgumentError, "The only valid options are :only and :except. You specified #{options.keys.join(',')}."
+      end
+      if options.has_key?(:only) && options.has_key?(:except)
+        raise ArgumentError, "You may only specify either :only or :either.  Doing both doesn't really make sense does it?"
+      end
+
+      @only = options[:only]
+      @tables_to_exclude = (options[:except] || [])
+      if migration_storage = migration_storage_name
+        @tables_to_exclude << migration_storage
+      end
+    end
+
+    def start
+      # no-op
+    end
+
+    def clean
+      raise NotImplementedError
+    end
+
+
+    private
+
+    def tables_to_truncate
+      raise NotImplementedError
+    end
+
+    # overwrite in subclasses
+    # default implementation given because migration storage need not be present
+    def migration_storage_name
+      nil
+    end
+
+  end
+end

data/spec/database_cleaner/active_record/transaction_spec.rb

@@ -0,0 +1,165 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/active_record/transaction'
+require 'active_record'
+
+module DatabaseCleaner
+  module ActiveRecord
+
+    describe Transaction do
+      let (:connection) { mock("connection") }
+      let (:another_connection) { mock("a different connection") }
+    
+      let (:model_klass) do
+        model_klass = mock("klass")
+        model_klass.stub!(:connection).and_return(another_connection)
+        model_klass
+      end
+
+      before(:each) do
+        ::ActiveRecord::Base.stub!(:connection).and_return(connection)
+      end
+
+      describe "start" do
+        context "single connection" do
+          it "should increment open transactions if possible" do
+            connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
+            connection.stub!(:begin_db_transaction)
+          
+            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)
+            connection.stub!(:begin_db_transaction)
+          
+            ::ActiveRecord::Base.should_receive(:increment_open_transactions)
+            Transaction.new.start
+          end
+        
+          it "should start a transaction" do
+              connection.stub!(:increment_open_transactions)
+            
+              connection.should_receive(:begin_db_transaction)
+              Transaction.new.start
+          end
+        end
+        
+        context "multiple connection" do
+          
+          before(:each) do            
+            DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
+          end
+
+          after(:each) do
+            DatabaseCleaner::ActiveRecord.connection_klasses = []
+          end
+          
+          it "should increment open transactions on both connections if possible" do
+            connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
+            connection.stub!(:begin_db_transaction)
+          
+            another_connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
+            another_connection.stub!(:begin_db_transaction)
+            
+            connection.should_receive(:increment_open_transactions)          
+            another_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)
+            connection.stub!(:begin_db_transaction)
+          
+            another_connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(false)
+            another_connection.stub!(:begin_db_transaction)
+          
+            ::ActiveRecord::Base.should_receive(:increment_open_transactions)
+            model_klass.should_receive(:increment_open_transactions)
+            Transaction.new.start
+          end
+        
+          it "should start a transaction" do
+              connection.stub!(:increment_open_transactions)
+              another_connection.stub!(:increment_open_transactions)
+            
+              connection.should_receive(:begin_db_transaction)
+              another_connection.should_receive(:begin_db_transaction)
+              Transaction.new.start
+          end
+        end
+      end
+      
+      describe "clean" do
+        context "single connection" do
+          it "should finish a transaction" do
+              connection.stub!(:decrement_open_transactions)
+
+              connection.should_receive(:rollback_db_transaction)
+              Transaction.new.clean
+          end
+          
+          it "should decrement open transactions if possible" do
+            connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
+            connection.stub!(:rollback_db_transaction)
+
+            connection.should_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
+
+          it "should decrement connection via ActiveRecord::Base if connection won't" do
+            connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
+            connection.stub!(:rollback_db_transaction)
+
+            ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
+        end
+        
+        context "multiple connection" do
+          before(:each) do            
+            DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
+          end
+
+          after(:each) do
+            DatabaseCleaner::ActiveRecord.connection_klasses = []
+          end
+          
+          it "should finish a transaction" do
+              connection.stub!(:decrement_open_transactions)
+              another_connection.stub!(:decrement_open_transactions)
+              
+              connection.should_receive(:rollback_db_transaction)
+              another_connection.should_receive(:rollback_db_transaction)
+              Transaction.new.clean
+          end
+          
+          it "should decrement open transactions if possible" do
+            connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
+            connection.stub!(:rollback_db_transaction)
+
+            another_connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
+            another_connection.stub!(:rollback_db_transaction)
+
+            connection.should_receive(:decrement_open_transactions)
+            another_connection.should_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
+
+          it "should decrement connection via ActiveRecord::Base if connection won't" do
+            connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
+            connection.stub!(:rollback_db_transaction)
+            
+            another_connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
+            another_connection.stub!(:rollback_db_transaction)
+
+            ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
+            model_klass.should_receive(:decrement_open_transactions)
+            Transaction.new.clean
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/database_cleaner/active_record/truncation_spec.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/active_record/truncation'
+require 'active_record'
+module ActiveRecord
+  module ConnectionAdapters
+    [MysqlAdapter, SQLite3Adapter, JdbcAdapter, PostgreSQLAdapter].each do |adapter|
+      describe adapter, "#truncate_table" do
+        it "should truncate the table"
+      end
+    end
+  end
+end
+
+module DatabaseCleaner
+  module ActiveRecord
+
+    describe Truncation do
+      let (:connection) { mock('connection') }
+      
+      before(:each) do
+        connection.stub!(:disable_referential_integrity).and_yield
+        ::ActiveRecord::Base.stub!(:connection).and_return(connection)
+      end
+
+      context "single connection" do
+        it "should truncate all tables except for schema_migrations" do
+          connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+          connection.should_receive(:truncate_table).with('widgets')
+          connection.should_receive(:truncate_table).with('dogs')
+          connection.should_not_receive(:truncate_table).with('schema_migrations')
+
+          Truncation.new.clean
+        end
+
+        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_table).with('widgets')
+          connection.should_not_receive(:truncate_table).with('dogs')
+
+          Truncation.new(:only => ['widgets']).clean
+        end
+
+        it "should not truncate the tables specified in the :except option" do
+          connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+          connection.should_receive(:truncate_table).with('dogs')
+          connection.should_not_receive(:truncate_table).with('widgets')
+
+          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
+      end
+      
+      context "multiple connection" do
+        
+        let (:another_connection) { mock('another connection') }
+        let (:model_klass) { mock('klass') }
+        
+        before(:each) do
+          another_connection.stub!(:disable_referential_integrity).and_yield
+          model_klass.stub!(:connection).and_return(another_connection)
+          
+          DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
+        end
+
+        after(:each) do
+          DatabaseCleaner::ActiveRecord.connection_klasses = []
+        end
+        
+        it "should truncate all tables except for schema_migrations on both connections" do
+          connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+          another_connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+          connection.should_receive(:truncate_table).with('widgets')
+          connection.should_receive(:truncate_table).with('dogs')
+          connection.should_not_receive(:truncate_table).with('schema_migrations')
+          
+          another_connection.should_receive(:truncate_table).with('widgets')
+          another_connection.should_receive(:truncate_table).with('dogs')
+          another_connection.should_not_receive(:truncate_table).with('schema_migrations')
+          
+          Truncation.new.clean
+        end
+
+        it "should only truncate the tables specified in the :only option when provided" do
+          connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+          another_connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+          connection.should_receive(:truncate_table).with('widgets')
+          connection.should_not_receive(:truncate_table).with('dogs')
+          
+          another_connection.should_receive(:truncate_table).with('widgets')
+          another_connection.should_not_receive(:truncate_table).with('dogs')
+
+          Truncation.new(:only => ['widgets']).clean
+        end
+
+        it "should not truncate the tables specified in the :except option" do
+          connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+          another_connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+          connection.should_receive(:truncate_table).with('dogs')
+          connection.should_not_receive(:truncate_table).with('widgets')
+          
+          another_connection.should_receive(:truncate_table).with('dogs')
+          another_connection.should_not_receive(:truncate_table).with('widgets')
+
+          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
+      end
+      
+    end
+
+  end
+end

data/spec/database_cleaner/configuration_spec.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'database_cleaner/active_record/transaction'
+require 'database_cleaner/data_mapper/transaction'
+
+
+describe DatabaseCleaner do
+
+  describe ActiveRecord do
+    describe "connections" do
+      it "should return an array of classes containing ActiveRecord::Base by default" do
+        ::DatabaseCleaner::ActiveRecord.connection_klasses.should == [::ActiveRecord::Base]
+      end
+      it "should merge in an array of classes to get connections from" do
+        model = mock("model")
+        ::DatabaseCleaner::ActiveRecord.connection_klasses = [model]
+        ::DatabaseCleaner::ActiveRecord.connection_klasses.should include model
+        ::DatabaseCleaner::ActiveRecord.connection_klasses.should include ::ActiveRecord::Base
+      end
+    end    
+  end
+
+  # These examples muck around with the constants for autodetection so we need to clean up....
+  before(:all) do
+    TempAR = ActiveRecord unless defined?(TempAR)
+    TempMM = MongoMapper unless defined?(TempMM)
+    Object.send(:remove_const, 'MongoMapper') if defined?(::MongoMapper)
+    # need to add one for each ORM that we load in the spec helper...
+  end
+  after(:all) do
+    Object.send(:remove_const, 'ActiveRecord') if defined?(::ActiveRecord) #want to make sure we have the real one...
+    ActiveRecord = TempAR
+    MongoMapper = TempMM
+  end
+
+  before(:each) do
+    DatabaseCleaner::ActiveRecord::Transaction.stub!(:new).and_return(@strategy = mock('strategy'))
+    Object.const_set('ActiveRecord', "just mocking out the constant here...") unless defined?(::ActiveRecord)
+    DatabaseCleaner.strategy = nil
+    DatabaseCleaner.orm = nil
+  end
+  
+  describe ".create_strategy" do
+    it "should initialize and return the appropirate strategy" do
+      DatabaseCleaner::ActiveRecord::Transaction.should_receive(:new).with('options' => 'hash')
+      result = DatabaseCleaner.create_strategy(:transaction, {'options' => 'hash'})
+      result.should == @strategy
+    end
+  end
+
+  describe ".clean_with" do
+    it "should initialize the appropirate strategy and clean with it" do
+      DatabaseCleaner::ActiveRecord::Transaction.should_receive(:new).with('options' => 'hash')
+      @strategy.should_receive(:clean)
+      DatabaseCleaner.clean_with(:transaction, 'options' => 'hash')
+    end
+  end
+
+  describe ".strategy=" do
+    it "should initialize the appropirate strategy based on the ORM adapter detected" do
+      DatabaseCleaner::ActiveRecord::Transaction.should_receive(:new).with('options' => 'hash')
+      DatabaseCleaner.strategy = :transaction, {'options' => 'hash'}
+
+      Object.send(:remove_const, 'ActiveRecord')
+      Object.const_set('DataMapper', "just mocking out the constant here...")
+      DatabaseCleaner.orm = nil
+
+      DatabaseCleaner::DataMapper::Transaction.should_receive(:new).with(no_args)
+      DatabaseCleaner.strategy = :transaction
+    end
+
+    it "should raise an error when no ORM is detected" do
+      Object.send(:remove_const, 'ActiveRecord') if defined?(::ActiveRecord)
+      Object.send(:remove_const, 'DataMapper') if defined?(::DataMapper)
+      Object.send(:remove_const, 'CouchPotato') if defined?(::CouchPotato)
+
+      running { DatabaseCleaner.strategy = :transaction }.should raise_error(DatabaseCleaner::NoORMDetected)
+    end
+
+    it "should use the strategy version of the ORM specified with #orm=" do
+      DatabaseCleaner.orm = 'data_mapper'
+      DatabaseCleaner::DataMapper::Transaction.should_receive(:new)
+
+      DatabaseCleaner.strategy = :transaction
+    end
+
+    it "should raise an error when multiple args is passed in and the first is not a symbol" do
+      running { DatabaseCleaner.strategy=Object.new, {:foo => 'bar'} }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error when the specified strategy is not found" do
+      running { DatabaseCleaner.strategy = :foo }.should raise_error(DatabaseCleaner::UnknownStrategySpecified)
+    end
+
+    it "should allow any object to be set as the strategy" do
+      mock_strategy = mock('strategy')
+      running { DatabaseCleaner.strategy = mock_strategy }.should_not raise_error
+    end
+
+  end
+
+
+    %w[start clean].each do |strategy_method|
+      describe ".#{strategy_method}" do
+        it "should be delgated to the strategy set with strategy=" do
+          DatabaseCleaner.strategy = :transaction
+
+          @strategy.should_receive(strategy_method)
+
+          DatabaseCleaner.send(strategy_method)
+        end
+
+        it "should raise en error when no strategy has been set" do
+          running { DatabaseCleaner.send(strategy_method) }.should raise_error(DatabaseCleaner::NoStrategySetError)
+        end
+      end
+    end
+
+end