database_cleaner 1.6.2 → 2.0.0

data/spec/database_cleaner/configuration_spec.rb

@@ -1,345 +0,0 @@
-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
-end
-
-describe ::DatabaseCleaner do
-  before(:each) { ::DatabaseCleaner.reset }
-
-  context "orm specification" do
-    it "should not accept unrecognised orms" do
-      expect { ::DatabaseCleaner[nil] }.to raise_error(::DatabaseCleaner::NoORMDetected)
-    end
-
-    it "should accept :active_record" do
-      cleaner = ::DatabaseCleaner[:active_record]
-      cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should eq :active_record
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-
-    it "should accept :data_mapper" do
-      cleaner = ::DatabaseCleaner[:data_mapper]
-      cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should eq :data_mapper
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-
-    it "should accept :mongo_mapper" do
-      cleaner = ::DatabaseCleaner[:mongo_mapper]
-      cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should eq :mongo_mapper
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-
-    it "should accept :couch_potato" do
-      cleaner = ::DatabaseCleaner[:couch_potato]
-      cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should eq :couch_potato
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-
-    it "should accept :moped" do
-      cleaner = ::DatabaseCleaner[:moped]
-      cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should eq :moped
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-
-    it 'accepts :ohm' do
-      cleaner = ::DatabaseCleaner[:ohm]
-      cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should eq :ohm
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-  end
-
-  it "should accept multiple orm's" do
-    ::DatabaseCleaner[:couch_potato]
-    ::DatabaseCleaner[:data_mapper]
-    ::DatabaseCleaner.connections.size.should eq 2
-    ::DatabaseCleaner.connections[0].orm.should eq :couch_potato
-    ::DatabaseCleaner.connections[1].orm.should eq :data_mapper
-  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 eq :active_record
-      cleaner.db.should eq :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 eq 2
-      ::DatabaseCleaner.connections[0].orm.should eq :data_mapper
-      ::DatabaseCleaner.connections[0].db.should  eq :first_db
-      ::DatabaseCleaner.connections[1].orm.should eq :data_mapper
-      ::DatabaseCleaner.connections[1].db.should  eq :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 eq 4
-
-      ::DatabaseCleaner.connections[0].orm.should eq :data_mapper
-      ::DatabaseCleaner.connections[0].db.should  eq :first_db
-
-      ::DatabaseCleaner.connections[1].orm.should eq :active_record
-      ::DatabaseCleaner.connections[1].db.should  eq :second_db
-
-      ::DatabaseCleaner.connections[2].orm.should eq :active_record
-      ::DatabaseCleaner.connections[2].db.should  eq :first_db
-
-      ::DatabaseCleaner.connections[3].orm.should eq :data_mapper
-      ::DatabaseCleaner.connections[3].db.should  eq :second_db
-    end
-  end
-
-  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 eq connection
-    end
-  end
-
-  context "class methods" do
-    subject { ::DatabaseCleaner }
-
-    it "should give me a default (autodetection) databasecleaner by default" do
-      cleaner = double("cleaner").as_null_object
-      ::DatabaseCleaner::Base.stub(:new).and_return(cleaner)
-
-      ::DatabaseCleaner.connections.should eq [cleaner]
-    end
-  end
-
-  context "single orm single connection" do
-    let(:connection) { ::DatabaseCleaner.connections.first }
-
-    it "should proxy strategy=" do
-      stratagum = double("stratagum")
-      connection.should_receive(:strategy=).with(stratagum)
-      ::DatabaseCleaner.strategy = stratagum
-    end
-
-    it "should proxy orm=" do
-      orm = double("orm")
-      connection.should_receive(:orm=).with(orm)
-      ::DatabaseCleaner.orm = orm
-    end
-
-    it "should proxy start" do
-      connection.should_receive(:start)
-      ::DatabaseCleaner.start
-    end
-
-    it "should proxy clean" do
-      connection.should_receive(:clean)
-      ::DatabaseCleaner.clean
-    end
-
-    it 'should proxy cleaning' do
-      connection.should_receive(:cleaning)
-      ::DatabaseCleaner.cleaning { }
-    end
-
-    it "should proxy clean_with" do
-      stratagem = double("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) { double("active_mock") }
-      let(:data_mapper)   { double("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 = double("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 initiate cleaning on each connection, yield, and finish cleaning each connection" do
-        [active_record, data_mapper].each do |connection|
-          mc = class << connection; self; end
-          mc.send(:attr_reader, :started, :cleaned)
-          mc.send(:define_method, 'cleaning') do |&block|
-            @started = true
-            block.call
-            @cleaned = true
-          end
-        end
-
-        ::DatabaseCleaner.cleaning do
-          active_record.started.should == true
-          data_mapper.started.should == true
-          active_record.cleaned.should == nil
-          data_mapper.cleaned.should == nil
-          @yielded = true
-        end
-        active_record.cleaned.should == true
-        data_mapper.cleaned.should == true
-      end
-
-      it "should proxy clean_with to all connections" do
-        stratagem = double("stratgem")
-        active_record.should_receive(:clean_with).with(stratagem)
-        data_mapper.should_receive(:clean_with).with(stratagem)
-
-        ::DatabaseCleaner.clean_with stratagem
-      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
-
-      pending "should proxy orm to all connections and remove duplicate connections" do
-        active_record_1 = double("active_mock_on_db_one").as_null_object
-        active_record_2 = double("active_mock_on_db_two").as_null_object
-        data_mapper_1   = double("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 eq 3
-        ::DatabaseCleaner.orm = :data_mapper
-        ::DatabaseCleaner.connections.size.should eq 2
-      end
-
-      it "should proxy strategy to all connections and remove duplicate connections" do
-        active_record_1 = double("active_mock_strategy_one").as_null_object
-        active_record_2 = double("active_mock_strategy_two").as_null_object
-        strategy = double("strategy")
-
-        ::DatabaseCleaner.connections_stub [active_record_1,active_record_2]
-
-        active_record_1.should_receive(:strategy=).with(strategy)
-        active_record_2.should_receive(:strategy=).with(strategy)
-
-        active_record_1.should_receive(:==).with(active_record_2).and_return(true)
-
-        ::DatabaseCleaner.connections.size.should eq 2
-        ::DatabaseCleaner.strategy = strategy
-        ::DatabaseCleaner.connections.size.should eq 1
-      end
-    end
-  end
-
-  describe "remove_duplicates" do
-    it "should remove duplicates if they are identical" do
-      orm = double("orm")
-      connection = double("a datamapper connection", :orm => orm )
-
-      ::DatabaseCleaner.connections_stub  [connection,connection,connection]
-
-      ::DatabaseCleaner.remove_duplicates
-      ::DatabaseCleaner.connections.size.should eq 1
-    end
-  end
-
-  describe "app_root" do
-    it "should default to Dir.pwd" do
-      DatabaseCleaner.app_root.should eq Dir.pwd
-    end
-
-    it "should store specific paths" do
-      DatabaseCleaner.app_root = '/path/to'
-      DatabaseCleaner.app_root.should eq '/path/to'
-    end
-  end
-
-  describe "orm_module" do
-    subject { ::DatabaseCleaner }
-
-    it "should return DatabaseCleaner::ActiveRecord for :active_record" do
-      ::DatabaseCleaner::ActiveRecord = double("ar module") unless defined? ::DatabaseCleaner::ActiveRecord
-      subject.orm_module(:active_record).should eq DatabaseCleaner::ActiveRecord
-    end
-
-    it "should return DatabaseCleaner::DataMapper for :data_mapper" do
-      ::DatabaseCleaner::DataMapper = double("dm module") unless defined? ::DatabaseCleaner::DataMapper
-      subject.orm_module(:data_mapper).should eq DatabaseCleaner::DataMapper
-    end
-
-    it "should return DatabaseCleaner::MongoMapper for :mongo_mapper" do
-      ::DatabaseCleaner::MongoMapper = double("mm module") unless defined? ::DatabaseCleaner::MongoMapper
-      subject.orm_module(:mongo_mapper).should eq DatabaseCleaner::MongoMapper
-    end
-
-    it "should return DatabaseCleaner::Mongoid for :mongoid" do
-      ::DatabaseCleaner::Mongoid = double("mongoid module") unless defined? ::DatabaseCleaner::Mongoid
-      subject.orm_module(:mongoid).should eq DatabaseCleaner::Mongoid
-    end
-
-    it "should return DatabaseCleaner::Mongo for :mongo" do
-      ::DatabaseCleaner::Mongo = double("mongo module") unless defined? ::DatabaseCleaner::Mongo
-      subject.orm_module(:mongo).should eq DatabaseCleaner::Mongo
-    end
-
-    it "should return DatabaseCleaner::CouchPotato for :couch_potato" do
-      ::DatabaseCleaner::CouchPotato = double("cp module") unless defined? ::DatabaseCleaner::CouchPotato
-      subject.orm_module(:couch_potato).should eq DatabaseCleaner::CouchPotato
-    end
-
-    it "should return DatabaseCleaner::Neo4j for :neo4j" do
-      ::DatabaseCleaner::Neo4j = double("nj module") unless defined? ::DatabaseCleaner::Neo4j
-      subject.orm_module(:neo4j).should eq DatabaseCleaner::Neo4j
-    end
-
-  end
-end

data/spec/database_cleaner/couch_potato/truncation_spec.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'database_cleaner/couch_potato/truncation'
-require 'couch_potato'
-
-module DatabaseCleaner
-  module CouchPotato
-
-    describe Truncation do
-      let(:database) { double('database') }
-
-      before(:each) do
-        ::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/data_mapper/base_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/data_mapper/base'
-require 'database_cleaner/shared_strategy'
-
-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 eq :my_db
-      end
-
-      it "should default to :default" do
-        subject.db.should eq :default
-      end
-    end
-  end
-end

data/spec/database_cleaner/data_mapper/transaction_spec.rb

@@ -1,23 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'database_cleaner/data_mapper/transaction'
-require 'database_cleaner/shared_strategy'
-#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/sqlite3_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'dm-core'
-require 'dm-sqlite-adapter'
-require File.expand_path('../../../../support/data_mapper/sqlite3_setup', __FILE__)
-require 'database_cleaner/data_mapper/truncation'
-
-module DataMapper
-  module ConnectionAdapters
-    describe do
-      before(:all) { data_mapper_sqlite3_setup }
-
-      let(:adapter) { DataMapperSQLite3Adapter }
-
-      let(:connection) do
-        data_mapper_sqlite3_connection
-      end
-
-      before(:each) do
-        connection.truncate_tables(DataMapper::Model.descendants.map { |d| d.storage_names[:default] || d.name.underscore })
-      end
-
-      describe "#truncate_table" do
-        it "truncates the table" do
-          2.times { DmUser.create }
-
-          connection.truncate_table(DmUser.storage_names[:default])
-          DmUser.count.should eq 0
-        end
-
-        it "resets AUTO_INCREMENT index of table" do
-          2.times { DmUser.create }
-          DmUser.destroy
-
-          connection.truncate_table(DmUser.storage_names[:default])
-
-          DmUser.create.id.should eq 1
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/data_mapper/truncation_spec.rb

@@ -1,11 +0,0 @@
-require 'database_cleaner/data_mapper/truncation'
-require 'database_cleaner/shared_strategy'
-
-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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/shared_strategy'
-require 'database_cleaner/generic/base'
-require 'active_record'
-
-module ::DatabaseCleaner
-  module Generic
-    class ExampleStrategy
-      include ::DatabaseCleaner::Generic::Base
-
-      def start; end
-    end
-
-    describe ExampleStrategy do
-      context "class methods" do
-        subject { ExampleStrategy }
-
-        describe "#available_strategies" do
-          it "should have available strategies" do
-            expect(subject.available_strategies).to be_empty
-          end
-        end
-      end
-
-      it_should_behave_like "a generic strategy"
-
-      describe "#db" do
-        it "should be :default" do
-          expect(subject.db).to eql(:default)
-        end
-      end
-
-      describe "#cleaning" do
-        let (:connection) { double("connection") }
-        let (:strategy) { ExampleStrategy.new }
-        before do
-          # DatabaseCleaner.strategy = :truncation
-          connection.stub(:disable_referential_integrity).and_yield
-          connection.stub(:database_cleaner_view_cache).and_return([])
-          connection.stub(:database_cleaner_table_cache).and_return([])
-          ::ActiveRecord::Base.stub(:connection).and_return(connection)
-        end
-
-        it "calls #clean even if there is an exception" do
-          strategy.should_receive :clean
-          expect do
-            strategy.cleaning do
-              raise NoMethodError
-            end
-          end.to raise_exception(NoMethodError)
-        end
-
-        it "calls #clean after processing the block" do
-          strategy.should_receive :clean
-          strategy.cleaning do
-          end
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/generic/truncation_spec.rb

@@ -1,118 +0,0 @@
-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
-
-      def reset_ids?
-        !!@reset_ids
-      end
-
-      def pre_count?
-        !!@pre_count
-      end
-    end
-
-    class MigrationExample < TruncationExample
-      def migration_storage_names
-        %w[migration_storage_name]
-      end
-    end
-
-    describe TruncationExample do
-      subject(:truncation_example) { TruncationExample.new }
-
-      it "will start" do
-        expect { truncation_example.start }.to_not raise_error
-      end
-
-      it "expects clean to be implemented later" do
-        expect { truncation_example.clean }.to raise_error(NotImplementedError)
-      end
-
-      context "private methods" do
-        it { should_not respond_to(:tables_to_truncate) }
-
-        it 'expects #tables_to_truncate to be implemented later' do
-          expect{ truncation_example.send :tables_to_truncate }.to raise_error(NotImplementedError)
-        end
-
-        it { should_not respond_to(:migration_storage_names) }
-        its(:migration_storage_names) { should be_empty }
-      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 }
-        it { expect{ TruncationExample.new( { :except => "something"                           } ) }.to_not raise_error }
-        it { expect{ TruncationExample.new( { :pre_count => "something"                        } ) }.to_not raise_error }
-        it { expect{ TruncationExample.new( { :reset_ids => "something"                        } ) }.to_not raise_error }
-
-        context "" do
-          subject { TruncationExample.new( { :only => ["something"] } ) }
-          its(:only)   { should eq ["something"] }
-          its(:except) { should eq [] }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :except => ["something"] } ) }
-          its(:only)   { should eq nil }
-          its(:except) { should include("something") }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :reset_ids => ["something"] } ) }
-          its(:reset_ids?) { should eq true }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :reset_ids => nil } ) }
-          its(:reset_ids?) { should eq false }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :pre_count => ["something"] } ) }
-          its(:pre_count?) { should eq true }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :pre_count => nil } ) }
-          its(:pre_count?) { should eq false }
-        end
-
-        context "" do
-          subject { MigrationExample.new }
-          its(:only)   { should eq nil }
-          its(:except) { should eq %w[migration_storage_name] }
-        end
-
-        context "" do
-          EXCEPT_TABLES = ["something"]
-          subject { MigrationExample.new( { :except => EXCEPT_TABLES } ) }
-
-          it "should not modify the array of excepted tables" do
-            subject.except.should include("migration_storage_name")
-            EXCEPT_TABLES.should_not include("migration_storage_name")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/mongo/mongo_examples.rb

@@ -1,26 +0,0 @@
-module MongoTest
-  class ThingBase
-    def self.collection
-      @connection ||= ::Mongo::Connection.new('127.0.0.1')
-      @db ||= @connection.db('database_cleaner_specs')
-      @mongo ||= @db.collection(name) || @db.create_collection(name)
-    end
-
-    def self.count
-      @mongo.count
-    end
-
-    def initialize(attrs={})
-      @attrs = attrs
-    end
-
-    def save!
-      self.class.collection.insert(@attrs)
-    end
-  end
-
-  class Widget < ThingBase
-  end
-  class Gadget < ThingBase
-  end
-end