bitfluent-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/mongoid/truncation.rb

@@ -0,0 +1,23 @@
+require 'database_cleaner/truncation_base'
+
+module DatabaseCleaner
+  module Mongoid
+    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 collections
+        ::Mongoid.database.collections
+      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,65 @@
+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") }
+      before(:each) do
+        ::ActiveRecord::Base.stub!(:connection).and_return(connection)
+      end
+
+      describe "#start" 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
+
+      describe "#clean" do
+        it "should start 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
+    end
+
+  end
+end

data/spec/database_cleaner/active_record/truncation_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/active_record/truncation'
+require 'active_record'
+module ActiveRecord
+  module ConnectionAdapters
+    [MysqlAdapter, Mysql2Adapter, 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
+      before(:each) do
+        @connection = mock('connection')
+        @connection.stub!(:disable_referential_integrity).and_yield
+        ::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_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
+
+  end
+end

data/spec/database_cleaner/configuration_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'database_cleaner/active_record/transaction'
+require 'database_cleaner/data_mapper/transaction'
+
+
+describe DatabaseCleaner do
+
+  # 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)
+    TempMI = Mongoid unless defined?(TempMI)
+    Object.send(:remove_const, 'MongoMapper') if defined?(::MongoMapper)
+    Object.send(:remove_const, 'Mongoid') if defined?(::Mongoid)
+    # 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
+	Mongoid = TempMI
+  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

data/spec/database_cleaner/couch_potato/truncation_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/couch_potato/truncation'
+require 'couch_potato'
+
+module DatabaseCleaner
+  module CouchPotato
+
+    describe Truncation do
+      before(:each) do
+        @database = mock('database')
+        ::CouchPotato.stub!(:couchrest_database).and_return(@database)
+      end
+
+      it "should re-create the database" do
+        @database.should_receive(:recreate!)
+
+        Truncation.new.clean
+      end
+
+      it "should raise an error when the :only option is used" do
+        running {
+          Truncation.new(:only => ['document-type'])
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error when the :except option is used" do
+        running {
+          Truncation.new(:except => ['document-type'])
+        }.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

data/spec/database_cleaner/mongo_mapper/truncation_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'mongo_mapper'
+require 'database_cleaner/mongo_mapper/truncation'
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
+TEST_DATABASE = 'database_cleaner_specs'
+MongoMapper.database = TEST_DATABASE
+
+class Widget
+  include MongoMapper::Document
+  key :name, String
+end
+class Gadget
+  include MongoMapper::Document
+  key :name, String
+end
+
+
+module DatabaseCleaner
+  module MongoMapper
+
+    describe Truncation do
+      before(:each) do
+        ::MongoMapper.connection.drop_database(TEST_DATABASE)
+        #::MongoMapper.connection.db(TEST_DATABASE).collections.each {|c| c.remove }
+        #::MongoMapper.database = TEST_DATABASE
+      end
+
+      def ensure_counts(expected_counts)
+        # I had to add this sanity_check garbage because I was getting non-determinisc results from mongomapper at times.. 
+        # very odd and disconcerting...
+        sanity_check = expected_counts.delete(:sanity_check)
+        begin
+          expected_counts.each do |model_class, expected_count|
+            model_class.count.should equal(expected_count), "#{model_class} expected to have a count of #{expected_count} but was #{model_class.count}"
+          end
+        rescue Spec::Expectations::ExpectationNotMetError => e
+          raise !sanity_check ? e : Spec::ExpectationNotMetError::ExpectationNotMetError.new("SANITY CHECK FAILURE! This should never happen here: #{e.message}")
+        end
+      end
+
+      def create_widget(attrs={})
+        Widget.new({:name => 'some widget'}.merge(attrs)).save!
+      end
+
+      def create_gadget(attrs={})
+        Gadget.new({:name => 'some gadget'}.merge(attrs)).save!
+      end
+
+      it "truncates all collections by default" do
+        create_widget
+        create_gadget
+        ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
+        Truncation.new.clean
+        ensure_counts(Widget => 0, Gadget => 0)
+      end
+
+      context "when collections are provided to the :only option" do
+        it "only truncates the specified collections" do
+          create_widget
+          create_gadget
+          ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
+          Truncation.new(:only => ['widgets']).clean
+          ensure_counts(Widget => 0, Gadget => 1)
+        end
+      end
+
+      context "when collections are provided to the :except option" do
+        it "truncates all but the specified collections" do
+          create_widget
+          create_gadget
+          ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
+          Truncation.new(:except => ['widgets']).clean
+          ensure_counts(Widget => 1, Gadget => 0)
+        end
+      end
+
+    end
+
+  end
+end