database_cleaner 0.5.0 → 0.6.0.rc.1

data/lib/database_cleaner/mongo_mapper/truncation.rb

@@ -1,13 +1,19 @@
-require 'database_cleaner/truncation_base'
+require 'database_cleaner/mongo_mapper/base'
+require 'database_cleaner/generic/truncation'
 
 module DatabaseCleaner
   module MongoMapper
-    class Truncation < DatabaseCleaner::TruncationBase
+    class Truncation
+      include ::DatabaseCleaner::MongoMapper::Base
+      include ::DatabaseCleaner::Generic::Truncation
+
       def clean
         if @only
           collections.each { |c| c.remove if @only.include?(c.name) }
-        else
+        elsif @tables_to_exclude
           collections.each { |c| c.remove unless @tables_to_exclude.include?(c.name) }
+        else
+          collections.each { |c| c.remove }
         end
         true
       end

data/lib/database_cleaner/mongoid/base.rb

@@ -0,0 +1,20 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module Mongoid
+    def self.available_strategies
+      %w[truncation]
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      def db=(desired_db)
+        @db = desired_db
+      end
+
+      def db
+        @db || :default
+      end
+    end
+  end
+end

data/lib/database_cleaner/mongoid/truncation.rb

@@ -0,0 +1,27 @@
+require 'database_cleaner/mongoid/base'
+require 'database_cleaner/generic/truncation'
+
+module DatabaseCleaner
+  module Mongoid
+    class Truncation
+      include ::DatabaseCleaner::Mongoid::Base
+      include ::DatabaseCleaner::Generic::Truncation
+
+      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/spec/database_cleaner/active_record/base_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'active_record'
+require 'database_cleaner/active_record/base'
+require 'database_cleaner/shared_strategy_spec'
+
+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
+        DatabaseCleaner.should_receive(:app_root).and_return("/path/to")
+        subject.should == '/path/to/config/database.yml'
+      end
+    end
+
+  end
+
+  module ActiveRecord
+    class ExampleStrategy
+      include ::DatabaseCleaner::ActiveRecord::Base
+    end
+
+    describe ExampleStrategy do
+
+      before { ::DatabaseCleaner::ActiveRecord.stub(:config_file_location).and_return('/path/to/config/database.yml') }
+
+      it_should_behave_like "a generic strategy"
+
+      describe "db" do
+        it { should respond_to(:db=) }
+
+        it "should store my desired db" do
+          subject.stub(:load_config)
+
+          subject.db = :my_db
+          subject.db.should == :my_db
+        end
+
+        it "should default to :default" do
+          subject.db.should == :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
+
+        it { should respond_to(:load_config) }
+
+        before do
+          yaml = <<-Y
+my_db:
+  database: <%= "ONE".downcase %>
+          Y
+          IO.stub(:read).with('/path/to/config/database.yml').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
+
+        it "should store the relevant config in connection_hash" do
+          subject.should_receive(:db).and_return(:my_db)
+          subject.load_config
+          subject.connection_hash.should == {"database" => "one"}
+        end
+      end
+
+      describe "connection_hash" do
+        it { should respond_to(:connection_hash) }
+        it { should respond_to(:connection_hash=) }
+        it "should store connection_hash" do
+          subject.connection_hash = { :key => "value" }
+          subject.connection_hash.should == { :key => "value" }
+        end
+      end
+
+      describe "create_connection_klass" do
+        it "should return a class" do
+          subject.create_connection_klass.should be_a(Class)
+        end
+
+        it "should return a class extending ::ActiveRecord::Base" do
+          subject.create_connection_klass.ancestors.should include(::ActiveRecord::Base)
+        end
+      end
+
+      describe "connection_klass" do
+        it { expect{ subject.connection_klass }.to_not raise_error }
+        it "should default to ActiveRecord::Base" do
+          subject.connection_klass.should == ::ActiveRecord::Base
+        end
+
+        context "when connection_hash is set" do
+          let(:hash) { mock("hash") }
+          before { subject.stub(:connection_hash).and_return(hash) }
+
+          it "should create connection_klass if it doesnt exist if connection_hash is set" do
+            subject.should_receive(:create_connection_klass).and_return(mock('class').as_null_object)
+            subject.connection_klass
+          end
+
+          it  "should configure the class from create_connection_klass if connection_hash is set" do
+            klass = mock('klass')
+            klass.should_receive(:establish_connection).with(hash)
+
+            subject.should_receive(:create_connection_klass).and_return(klass)
+            subject.connection_klass
+          end
+        end
+      end
+    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

@@ -1,9 +1,11 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
-require 'database_cleaner/active_record/truncation'
 require 'active_record'
+require 'database_cleaner/active_record/truncation'
+
+
 module ActiveRecord
   module ConnectionAdapters
-    [MysqlAdapter, SQLite3Adapter, JdbcAdapter, PostgreSQLAdapter].each do |adapter|
+    [MysqlAdapter, Mysql2Adapter, SQLite3Adapter, JdbcAdapter, PostgreSQLAdapter].each do |adapter|
       describe adapter, "#truncate_table" do
         it "should truncate the table"
       end
@@ -15,36 +17,38 @@ module DatabaseCleaner
   module ActiveRecord
 
     describe Truncation do
+      let(:connection) { mock('connection') }
+
+
       before(:each) do
-        @connection = mock('connection')
-        @connection.stub!(:disable_referential_integrity).and_yield
-        ::ActiveRecord::Base.stub!(:connection).and_return(@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.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')
+        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.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
 
-        @connection.should_receive(:truncate_table).with('widgets')
-        @connection.should_not_receive(:truncate_table).with('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.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
 
-        @connection.should_receive(:truncate_table).with('dogs')
-        @connection.should_not_receive(:truncate_table).with('widgets')
+        connection.should_receive(:truncate_table).with('dogs')
+        connection.should_not_receive(:truncate_table).with('widgets')
 
         Truncation.new(:except => ['widgets']).clean
       end
@@ -58,9 +62,6 @@ module DatabaseCleaner
       it "should raise an error when invalid options are provided" do
         running { Truncation.new(:foo => 'bar') }.should raise_error(ArgumentError)
       end
-
-
     end
-
   end
 end