mirror of
https://github.com/DatabaseCleaner/database_cleaner
synced 2023-03-27 23:22:03 -04:00
345 lines
12 KiB
Ruby
345 lines
12 KiB
Ruby
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
|