database_cleaner 0.5.0 → 0.6.0.rc.1

data/spec/database_cleaner/configuration_spec.rb

@@ -1,104 +1,294 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'database_cleaner/active_record/transaction'
-require 'database_cleaner/data_mapper/transaction'
 
+module DatabaseCleaner
+  class << self
+    def reset
+      @connections = nil
+    end
+
+    def connections_stub!(array)
+      @connections = array
+    end
+  end
+end
+
+describe ::DatabaseCleaner do
+  before(:each) { ::DatabaseCleaner.reset }
+
+  context "orm specification" do
+    it "should not accept unrecognised orms" do
+      expect { ::DatabaseCleaner[nil] }.should raise_error(::DatabaseCleaner::NoORMDetected)
+    end
 
-describe DatabaseCleaner do
+    it "should accept :active_record" do
+      cleaner = ::DatabaseCleaner[:active_record]
+      cleaner.should be_a(::DatabaseCleaner::Base)
+      cleaner.orm.should == :active_record
+      ::DatabaseCleaner.connections.size.should == 1
+    end
+
+    it "should accept :data_mapper" do
+      cleaner = ::DatabaseCleaner[:data_mapper]
+      cleaner.should be_a(::DatabaseCleaner::Base)
+      cleaner.orm.should == :data_mapper
+      ::DatabaseCleaner.connections.size.should == 1
+    end
+
+    it "should accept :mongo_mapper" do
+      cleaner = ::DatabaseCleaner[:mongo_mapper]
+      cleaner.should be_a(::DatabaseCleaner::Base)
+      cleaner.orm.should == :mongo_mapper
+      ::DatabaseCleaner.connections.size.should == 1
+    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...
+    it "should accept :couch_potato" do
+      cleaner = ::DatabaseCleaner[:couch_potato]
+      cleaner.should be_a(::DatabaseCleaner::Base)
+      cleaner.orm.should == :couch_potato
+      ::DatabaseCleaner.connections.size.should == 1
+    end
   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
+  
+  it "should accept multiple orm's" do
+    ::DatabaseCleaner[:couch_potato]
+    ::DatabaseCleaner[:data_mapper]
+    ::DatabaseCleaner.connections.size.should == 2
+    ::DatabaseCleaner.connections[0].orm.should == :couch_potato
+    ::DatabaseCleaner.connections[1].orm.should == :data_mapper
   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
+  context "connection/db specification" do
+    it "should accept a connection parameter and store it" do
+      cleaner = ::DatabaseCleaner[:active_record, {:connection => :first_connection}]
+      cleaner.should be_a(::DatabaseCleaner::Base)
+      cleaner.orm.should == :active_record
+      cleaner.db.should == :first_connection
+    end
+    
+    it "should accept multiple connections for a single orm" do
+      ::DatabaseCleaner[:data_mapper,{:connection => :first_db}]
+      ::DatabaseCleaner[:data_mapper,{:connection => :second_db}]
+      ::DatabaseCleaner.connections.size.should == 2
+      ::DatabaseCleaner.connections[0].orm.should == :data_mapper
+      ::DatabaseCleaner.connections[0].db.should  == :first_db
+      ::DatabaseCleaner.connections[1].orm.should == :data_mapper
+      ::DatabaseCleaner.connections[1].db.should  == :second_db
+    end
+    
+    it "should accept multiple connections and multiple orms" do
+      ::DatabaseCleaner[:data_mapper,  {:connection => :first_db} ]
+      ::DatabaseCleaner[:active_record,{:connection => :second_db}]
+      ::DatabaseCleaner[:active_record,{:connection => :first_db} ]
+      ::DatabaseCleaner[:data_mapper,  {:connection => :second_db}]
+
+      ::DatabaseCleaner.connections.size.should == 4
+
+      ::DatabaseCleaner.connections[0].orm.should == :data_mapper
+      ::DatabaseCleaner.connections[0].db.should  == :first_db
+
+      ::DatabaseCleaner.connections[1].orm.should == :active_record
+      ::DatabaseCleaner.connections[1].db.should  == :second_db
 
-  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
+      ::DatabaseCleaner.connections[2].orm.should == :active_record
+      ::DatabaseCleaner.connections[2].db.should  == :first_db
+
+      ::DatabaseCleaner.connections[3].orm.should == :data_mapper
+      ::DatabaseCleaner.connections[3].db.should  == :second_db
     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')
+  context "connection/db retrieval" do
+    it "should retrieve a db rather than create a new one" do
+      pending
+      connection = ::DatabaseCleaner[:active_record].strategy = :truncation
+      ::DatabaseCleaner[:active_record].should == connection
     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'}
+  context "class methods" do
+    subject { ::DatabaseCleaner }
+
+    its(:connections) { should respond_to(:each) }
 
-      Object.send(:remove_const, 'ActiveRecord')
-      Object.const_set('DataMapper', "just mocking out the constant here...")
-      DatabaseCleaner.orm = nil
+    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::DataMapper::Transaction.should_receive(:new).with(no_args)
-      DatabaseCleaner.strategy = :transaction
+      ::DatabaseCleaner.connections.should have(1).items
+      ::DatabaseCleaner.connections.first.should == cleaner
     end
+  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)
+  context "single orm single connection" do
+    let(:connection) { ::DatabaseCleaner.connections.first }
 
-      running { DatabaseCleaner.strategy = :transaction }.should raise_error(DatabaseCleaner::NoORMDetected)
+    it "should proxy strategy=" do
+      stratagum = mock("stratagum")
+      connection.should_receive(:strategy=).with(stratagum)
+      ::DatabaseCleaner.strategy = stratagum
     end
 
-    it "should use the strategy version of the ORM specified with #orm=" do
-      DatabaseCleaner.orm = 'data_mapper'
-      DatabaseCleaner::DataMapper::Transaction.should_receive(:new)
+    it "should proxy orm=" do
+      orm = mock("orm")
+      connection.should_receive(:orm=).with(orm)
+      ::DatabaseCleaner.orm = orm
+    end
 
-      DatabaseCleaner.strategy = :transaction
+    it "should proxy start" do
+      connection.should_receive(:start)
+      ::DatabaseCleaner.start
     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)
+    it "should proxy clean" do
+      connection.should_receive(:clean)
+      ::DatabaseCleaner.clean
     end
 
-    it "should raise an error when the specified strategy is not found" do
-      running { DatabaseCleaner.strategy = :foo }.should raise_error(DatabaseCleaner::UnknownStrategySpecified)
+    it "should proxy clean_with" do
+      stratagem = mock("stratgem")
+      connection.should_receive(:clean_with).with(stratagem)
+      ::DatabaseCleaner.clean_with stratagem
     end
+  end
+
+  context "multiple connections" do
+
+    #these are relativly simple, all we need to do is make sure all connections are cleaned/started/cleaned_with appropriatly.
+    context "simple proxy methods" do
+
+      let(:active_record) { mock("active_mock") }
+      let(:data_mapper)   { mock("data_mock")   }
+
+      before(:each) do
+        ::DatabaseCleaner.stub!(:connections).and_return([active_record,data_mapper])
+      end
+
+      it "should proxy orm to all connections" do
+        active_record.should_receive(:orm=)
+        data_mapper.should_receive(:orm=)
+
+        ::DatabaseCleaner.orm = mock("orm")
+      end
+
+      it "should proxy start to all connections" do
+        active_record.should_receive(:start)
+        data_mapper.should_receive(:start)
+
+        ::DatabaseCleaner.start
+      end
+
+      it "should proxy clean to all connections" do
+        active_record.should_receive(:clean)
+        data_mapper.should_receive(:clean)
+
+        ::DatabaseCleaner.clean
+      end
+
+      it "should proxy clean_with to all connections" do
+        stratagem = mock("stratgem")
+        active_record.should_receive(:clean_with).with(stratagem)
+        data_mapper.should_receive(:clean_with).with(stratagem)
 
-    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
+        ::DatabaseCleaner.clean_with stratagem
+      end
     end
 
-  end
+    # ah now we have some difficulty, we mustn't allow duplicate connections to exist, but they could
+    # 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
+        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
+
+        ::DatabaseCleaner.connections_stub! [active_record_1,active_record_2,data_mapper_1]
+
+        active_record_1.should_receive(:orm=).with(:data_mapper)
+        active_record_2.should_receive(:orm=).with(:data_mapper)
+        data_mapper_1.should_receive(:orm=).with(:data_mapper)
+
+        active_record_1.should_receive(:==).with(data_mapper_1).and_return(true)
+
+        ::DatabaseCleaner.connections.size.should == 3
+        ::DatabaseCleaner.orm = :data_mapper
+        ::DatabaseCleaner.connections.size.should == 2
+      end
 
+      it "should proxy strategy to all connections and remove duplicate connections" do
+        active_record_1 = mock("active_mock_strategy_one").as_null_object
+        active_record_2 = mock("active_mock_strategy_two").as_null_object
+        strategy = mock("strategy")
 
-    %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
+        ::DatabaseCleaner.connections_stub! [active_record_1,active_record_2]
 
-          @strategy.should_receive(strategy_method)
+        active_record_1.should_receive(:strategy=).with(strategy)
+        active_record_2.should_receive(:strategy=).with(strategy)
 
-          DatabaseCleaner.send(strategy_method)
-        end
+        active_record_1.should_receive(:==).with(active_record_2).and_return(true)
 
-        it "should raise en error when no strategy has been set" do
-          running { DatabaseCleaner.send(strategy_method) }.should raise_error(DatabaseCleaner::NoStrategySetError)
-        end
+        ::DatabaseCleaner.connections.size.should == 2
+        ::DatabaseCleaner.strategy = strategy
+        ::DatabaseCleaner.connections.size.should == 1
       end
     end
+  end
+
+  describe "remove_duplicates" do
+    it "should remove duplicates if they are identical" do
+      orm = mock("orm")
+      connection = mock("a datamapper connection", :orm => orm )
+      
+      ::DatabaseCleaner.connections_stub!  [connection,connection,connection]
+
+      ::DatabaseCleaner.remove_duplicates
+      ::DatabaseCleaner.connections.size.should == 1
+    end
+  end
+
+  describe "app_root" do
+    it "should default to Dir.pwd" do
+      DatabaseCleaner.app_root.should == Dir.pwd
+    end
 
+    it "should store specific paths" do
+      DatabaseCleaner.app_root = '/path/to'
+      DatabaseCleaner.app_root.should == '/path/to'
+    end
+  end
+  
+  describe "orm_module" do
+    subject { ::DatabaseCleaner }
+    
+    it "should return DatabaseCleaner::ActiveRecord for :active_record" do
+      ::DatabaseCleaner::ActiveRecord = mock("ar module") unless defined? ::DatabaseCleaner::ActiveRecord
+      subject.orm_module(:active_record).should == DatabaseCleaner::ActiveRecord
+    end
+    
+    it "should return DatabaseCleaner::DataMapper for :data_mapper" do
+      ::DatabaseCleaner::DataMapper = mock("dm module") unless defined? ::DatabaseCleaner::DataMapper
+      subject.orm_module(:data_mapper).should == DatabaseCleaner::DataMapper
+    end
+    
+    it "should return DatabaseCleaner::MongoMapper for :mongo_mapper" do
+      ::DatabaseCleaner::MongoMapper = mock("mm module") unless defined? ::DatabaseCleaner::MongoMapper
+      subject.orm_module(:mongo_mapper).should == DatabaseCleaner::MongoMapper
+    end
+    
+    it "should return DatabaseCleaner::Mongoid for :mongoid" do
+      ::DatabaseCleaner::Mongoid = mock("mongoid module") unless defined? ::DatabaseCleaner::Mongoid
+      subject.orm_module(:mongoid).should == DatabaseCleaner::Mongoid
+    end
+    
+    it "should return DatabaseCleaner::Mongo for :mongo" do
+      ::DatabaseCleaner::Mongo = mock("mongo module") unless defined? ::DatabaseCleaner::Mongo
+      subject.orm_module(:mongo).should == DatabaseCleaner::Mongo
+    end
+          
+    it "should return DatabaseCleaner::CouchPotato for :couch_potato" do
+      ::DatabaseCleaner::CouchPotato = mock("cp module") unless defined? ::DatabaseCleaner::CouchPotato
+      subject.orm_module(:couch_potato).should == DatabaseCleaner::CouchPotato
+    end
+    
+  end
 end

data/spec/database_cleaner/couch_potato/truncation_spec.rb

@@ -6,13 +6,14 @@ module DatabaseCleaner
   module CouchPotato
 
     describe Truncation do
+      let(:database) { mock('database') }
+
       before(:each) do
-        @database = mock('database')
-        ::CouchPotato.stub!(:couchrest_database).and_return(@database)
+        ::CouchPotato.stub!(:couchrest_database).and_return(database)
       end
 
       it "should re-create the database" do
-        @database.should_receive(:recreate!)
+        database.should_receive(:recreate!)
 
         Truncation.new.clean
       end

data/spec/database_cleaner/data_mapper/base_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'database_cleaner/data_mapper/base'
+require 'database_cleaner/shared_strategy_spec'
+
+module DatabaseCleaner
+  describe DataMapper do
+    it { should respond_to(:available_strategies) }
+  end
+
+  module DataMapper
+    class ExampleStrategy
+      include ::DatabaseCleaner::DataMapper::Base
+    end
+
+    describe ExampleStrategy do
+      it_should_behave_like "a generic strategy"
+      it { should respond_to(:db)  }
+      it { should respond_to(:db=) }
+
+      it "should store my desired db" do
+        subject.db = :my_db
+        subject.db.should == :my_db
+      end
+
+      it "should default to :default" do
+        subject.db.should == :default
+      end
+    end
+  end
+end

data/spec/database_cleaner/data_mapper/transaction_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/data_mapper/transaction'
+require 'database_cleaner/shared_strategy_spec'
+#require 'data_mapper'
+
+module DatabaseCleaner
+  module DataMapper
+
+    describe Transaction do
+      it_should_behave_like "a generic strategy"
+      it_should_behave_like "a generic transaction strategy"
+
+      describe "start" do
+        it "should start a transaction"
+      end
+
+      describe "clean" do
+        it "should finish a transaction"
+      end
+    end
+
+  end
+end

data/spec/database_cleaner/data_mapper/truncation_spec.rb

@@ -0,0 +1,11 @@
+require 'database_cleaner/data_mapper/truncation'
+require 'database_cleaner/shared_strategy_spec'
+
+module DatabaseCleaner
+  module DataMapper
+    describe Truncation do
+      it_should_behave_like "a generic strategy"
+      it_should_behave_like "a generic truncation strategy"
+    end
+  end
+end

data/spec/database_cleaner/generic/base_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'database_cleaner/shared_strategy_spec'
+require 'database_cleaner/generic/base'
+
+module ::DatabaseCleaner
+  module Generic
+    class ExampleStrategy
+      include ::DatabaseCleaner::Generic::Base
+    end
+
+    describe ExampleStrategy do
+      context "class methods" do
+        subject { ExampleStrategy }
+        its(:available_strategies) { should be_empty }
+      end
+
+      it_should_behave_like "a generic strategy"
+
+      its(:db) { should == :default }
+    end
+  end
+end

data/spec/database_cleaner/generic/truncation_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'database_cleaner/generic/truncation'
+
+module ::DatabaseCleaner
+  module Generic
+    class TruncationExample
+      include ::DatabaseCleaner::Generic::Truncation
+
+      def only
+        @only
+      end
+
+      def except
+        @tables_to_exclude
+      end
+    end
+
+    class MigrationExample < TruncationExample
+      def migration_storage_name
+        "migration_storage_name"
+      end
+    end
+
+    describe TruncationExample do
+      its(:start) { expect{ subject }.to_not raise_error }
+      its(:clean) { expect{ subject }.to raise_error(NotImplementedError) }
+
+      context "private methods" do
+        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 }
+      end
+
+      describe "initialize" do
+        it { expect{ subject }.to_not raise_error }
+
+        it "should accept a hash of options" do
+          expect{ TruncationExample.new {} }.to_not raise_error
+        end
+
+        it { expect{ TruncationExample.new( { :a_random_param => "should raise ArgumentError"  } ) }.to     raise_error(ArgumentError) }
+        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) }
+
+        context "" do
+          subject { TruncationExample.new( { :only => ["something"] } ) }
+          its(:only)   { should == ["something"] }
+          its(:except) { should == [] }
+        end
+
+        context "" do
+          subject { TruncationExample.new( { :except => ["something"] } ) }
+          its(:only)   { should == nil }
+          its(:except) { should include("something") }
+        end
+
+        context "" do
+          subject { MigrationExample.new }
+          its(:only)   { should == nil }
+          its(:except) { should == ["migration_storage_name"] }
+        end
+      end
+    end
+  end
+end

data/spec/database_cleaner/mongo_mapper/base_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'database_cleaner/mongo_mapper/base'
+require 'database_cleaner/shared_strategy_spec'
+
+module DatabaseCleaner
+  describe MongoMapper do
+    it { should respond_to(:available_strategies) }
+  end
+
+  module MongoMapper
+    class ExampleStrategy
+      include ::DatabaseCleaner::MongoMapper::Base
+    end
+
+    describe ExampleStrategy do
+
+      it_should_behave_like "a generic strategy"
+
+      describe "db" do
+        it { should respond_to(:db=) }
+
+        it "should store my desired db" do
+          subject.db = :my_db
+          subject.db.should == :my_db
+        end
+
+        it "should default to :default" do
+          subject.db.should == :default
+        end
+      end
+    end
+  end
+end

data/spec/database_cleaner/mongo_mapper/mongo_examples.rb

@@ -0,0 +1,8 @@
+class Widget
+  include ::MongoMapper::Document
+  key :name, String
+end
+class Gadget
+  include ::MongoMapper::Document
+  key :name, String
+end

data/spec/database_cleaner/mongo_mapper/truncation_spec.rb

@@ -1,33 +1,26 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
-require 'mongomapper'
+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
-
+require File.dirname(__FILE__) + '/mongo_examples'
 
 module DatabaseCleaner
   module MongoMapper
 
     describe Truncation do
+
+      #doing this in the file root breaks autospec, doing it before(:all) just fails the specs
+      before(:all) do
+          ::MongoMapper.connection = ::Mongo::Connection.new('127.0.0.1')
+          @test_db = 'database_cleaner_specs'
+          ::MongoMapper.database = @test_db
+      end
+
       before(:each) do
-        ::MongoMapper.connection.drop_database(TEST_DATABASE)
-        #::MongoMapper.connection.db(TEST_DATABASE).collections.each {|c| c.remove }
-        #::MongoMapper.database = TEST_DATABASE
+        ::MongoMapper.connection.drop_database(@test_db)
       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.. 
+        # 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