kotovalexarian-likes-github
/
database_cleaner
mirror of https://github.com/DatabaseCleaner/database_cleaner
1
0
Fork 0
Code Releases Activity

more specs, adaptors

This commit is contained in:
Jon Rowe 2010-04-07 22:35:46 +01:00
parent 31ef2bbc71
commit 06c497cec0
17 changed files with 413 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
lib/database_cleaner/active_record/adaptor.rb Normal file
View File

@ -0,0 +1,17 @@
require 'database_cleaner/strategy_base'
module DatabaseCleaner
module ActiveRecord
def self.available_strategies
%w[truncation transaction]
end
module Adaptor
include ::DatabaseCleaner::StrategyBase
def connection_klass
::ActiveRecord::Base
end
end
end
end

31
lib/database_cleaner/active_record/transaction.rb
View File

@ -1,30 +1,25 @@
module DatabaseCleaner::ActiveRecord
class Transaction
include ::DatabaseCleaner::ActiveRecord::Adaptor
def start
DatabaseCleaner::ActiveRecord.connection_klasses.each do |klass|
if klass.connection.respond_to?(:increment_open_transactions)
klass.connection.increment_open_transactions
else
klass.__send__(:increment_open_transactions)
end
klass.connection.begin_db_transaction
if connection_klass.connection.respond_to?(:increment_open_transactions)
connection_klass.connection.increment_open_transactions
else
connection_klass.__send__(:increment_open_transactions)
end
connection_klass.connection.begin_db_transaction
end
def clean
DatabaseCleaner::ActiveRecord.connection_klasses.each do |klass|
klass.connection.rollback_db_transaction
connection_klass.connection.rollback_db_transaction
if klass.connection.respond_to?(:decrement_open_transactions)
klass.connection.decrement_open_transactions
else
klass.__send__(:decrement_open_transactions)
end
if connection_klass.connection.respond_to?(:decrement_open_transactions)
connection_klass.connection.decrement_open_transactions
else
connection_klass.__send__(:decrement_open_transactions)
end
end
end
end
end

35
lib/database_cleaner/active_record/truncation.rb
View File

@ -1,6 +1,7 @@
require 'active_record/base'
require 'active_record/connection_adapters/abstract_adapter'
require "database_cleaner/truncation_base"
require 'database_cleaner/active_record/adaptor'
module ActiveRecord
module ConnectionAdapters
@ -36,7 +37,7 @@ module ActiveRecord
class PostgreSQLAdapter < AbstractAdapter
def self.db_version
@db_version ||= ActiveRecord::Base.connection.select_values(
@db_version ||= connection.select_values(
"SELECT CHARACTER_VALUE
FROM INFORMATION_SCHEMA.SQL_IMPLEMENTATION_INFO
WHERE IMPLEMENTATION_INFO_NAME = 'DBMS VERSION' ").to_s
@ -70,35 +71,27 @@ end
module DatabaseCleaner::ActiveRecord
class Truncation < ::DatabaseCleaner::TruncationBase
include ::DatabaseCleaner::ActiveRecord::Adaptor
def clean
connections.each do |connection|
connection.disable_referential_integrity do
tables_to_truncate_for_connection(connection).each do |table_name|
connection.truncate_table table_name
end
connection.disable_referential_integrity do
tables_to_truncate.each do |table_name|
connection.truncate_table table_name
end
end
end
private
def tables_to_truncate_for_connection(connection)
(@only || connection.tables) - @tables_to_exclude
end
# def tables_to_truncate
# (@only || connection.tables) - @tables_to_exclude
# end
# def connection
# ::ActiveRecord::Base.connection
# end
def connections
DatabaseCleaner::ActiveRecord.connection_klasses.map{ |klass| klass.connection }
def tables_to_truncate
(@only || connection.tables) - @tables_to_exclude
end
def connection
#::ActiveRecord::Base.connection
connection_klass.connection
end
# overwritten
def migration_storage_name
'schema_migrations'

6
lib/database_cleaner/base.rb
View File

@ -80,7 +80,11 @@ module DatabaseCleaner
require "database_cleaner/#{orm.to_s}/#{strategy.to_s}"
orm_module.const_get(strategy.to_s.capitalize)
rescue LoadError => e
raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM! Available strategies: #{orm_module.available_strategies.join(', ')}"
if orm_module.respond_to? :available_strategies
raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM! Available strategies: #{orm_module.available_strategies.join(', ')}"
else
raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!"
end
end
def autodetect

57
lib/database_cleaner/configuration.rb
View File

@ -1,4 +1,8 @@
require 'database_cleaner/base'
require 'database_cleaner/active_record/adaptor'
require 'database_cleaner/data_mapper/adaptor'
#require 'database_cleaner/mongo_mapper/adaptor'
#require 'database_cleaner/couch_potato/adaptor'
module DatabaseCleaner
@ -6,38 +10,19 @@ module DatabaseCleaner
class NoORMDetected < StandardError; end
class UnknownStrategySpecified < ArgumentError; end
module ActiveRecord
def self.available_strategies
%w[truncation transaction]
end
def self.connection_klasses
@klasses || [::ActiveRecord::Base]
end
def self.connection_klasses=(other)
other.concat [::ActiveRecord::Base] unless other.include? ::ActiveRecord::Base
@klasses = other
end
end
module DataMapper
def self.available_strategies
%w[truncation transaction]
end
end
module MongoMapper
def self.available_strategies
%w[truncation]
end
end
module CouchPotato
def self.available_strategies
%w[truncation]
end
end
#
# module MongoMapper
# def self.available_strategies
# %w[truncation]
# end
# end
#
# module CouchPotato
# def self.available_strategies
# %w[truncation]
# end
# end
class << self
def [](orm,opts = {})
@ -53,11 +38,13 @@ module DatabaseCleaner
end
def strategy=(stratagem)
self.connections.first.strategy = stratagem
self.connections.each { |connect| connect.strategy = stratagem }
remove_duplicates
end
def orm=(orm)
self.connections.first.orm = orm
self.connections.each { |connect| connect.orm = orm }
remove_duplicates
end
def start
@ -74,7 +61,7 @@ module DatabaseCleaner
def remove_duplicates
temp = []
@connections.each do |connect|
self.connections.each do |connect|
temp.push connect unless temp.include? connect
end
@connections = temp

7
lib/database_cleaner/couch_potato/adaptor.rb Normal file
View File

@ -0,0 +1,7 @@
module DatabaseCleaner
module CouchPotato
def self.available_strategies
%w[truncation]
end
end
end

7
lib/database_cleaner/data_mapper/adaptor.rb Normal file
View File

@ -0,0 +1,7 @@
module ActiveRecord
module DataMapper
def self.available_strategies
%w[truncation transaction]
end
end
end

11
lib/database_cleaner/strategy_base.rb Normal file
View File

@ -0,0 +1,11 @@
module DatabaseCleaner
module StrategyBase
def db=(desired_db)
@db = desired_db
end
def db
@db || :default
end
end
end

19
spec/database_cleaner/active_record/adaptor_spec.rb Normal file
View File

@ -0,0 +1,19 @@
require 'spec_helper'
require 'database_cleaner/active_record/adaptor'
require 'database_cleaner/shared_adaptor_spec'
class ExampleStrategy
include ::DatabaseCleaner::ActiveRecord::Adaptor
end
module DatabaseCleaner
describe ActiveRecord do
it { should respond_to :available_strategies }
end
module ActiveRecord
describe ExampleStrategy do
it_should_behave_like "database cleaner adaptor"
end
end
end

162
spec/database_cleaner/active_record/transaction_spec.rb
View File

@ -46,47 +46,48 @@ module DatabaseCleaner
end
context "multiple connection" do
before(:each) do
DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
end
after(:each) do
DatabaseCleaner::ActiveRecord.connection_klasses = []
end
it "should increment open transactions on both connections if possible" do
connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
connection.stub!(:begin_db_transaction)
another_connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
another_connection.stub!(:begin_db_transaction)
connection.should_receive(:increment_open_transactions)
another_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)
another_connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(false)
another_connection.stub!(:begin_db_transaction)
::ActiveRecord::Base.should_receive(:increment_open_transactions)
model_klass.should_receive(:increment_open_transactions)
Transaction.new.start
end
it "should start a transaction" do
connection.stub!(:increment_open_transactions)
another_connection.stub!(:increment_open_transactions)
connection.should_receive(:begin_db_transaction)
another_connection.should_receive(:begin_db_transaction)
Transaction.new.start
end
it "should has specs?"
# before(:each) do
# DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
# end
#
# after(:each) do
# DatabaseCleaner::ActiveRecord.connection_klasses = []
# end
#
# it "should increment open transactions on both connections if possible" do
# connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
# connection.stub!(:begin_db_transaction)
#
# another_connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
# another_connection.stub!(:begin_db_transaction)
#
# connection.should_receive(:increment_open_transactions)
# another_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)
#
# another_connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(false)
# another_connection.stub!(:begin_db_transaction)
#
# ::ActiveRecord::Base.should_receive(:increment_open_transactions)
# model_klass.should_receive(:increment_open_transactions)
# Transaction.new.start
# end
#
# it "should start a transaction" do
# connection.stub!(:increment_open_transactions)
# another_connection.stub!(:increment_open_transactions)
#
# connection.should_receive(:begin_db_transaction)
# another_connection.should_receive(:begin_db_transaction)
# Transaction.new.start
# end
end
end
@ -117,46 +118,47 @@ module DatabaseCleaner
end
context "multiple connection" do
before(:each) do
DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
end
after(:each) do
DatabaseCleaner::ActiveRecord.connection_klasses = []
end
it "should finish a transaction" do
connection.stub!(:decrement_open_transactions)
another_connection.stub!(:decrement_open_transactions)
connection.should_receive(:rollback_db_transaction)
another_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)
another_connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
another_connection.stub!(:rollback_db_transaction)
connection.should_receive(:decrement_open_transactions)
another_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)
another_connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
another_connection.stub!(:rollback_db_transaction)
::ActiveRecord::Base.should_receive(:decrement_open_transactions)
model_klass.should_receive(:decrement_open_transactions)
Transaction.new.clean
end
it "should has specs?"
# before(:each) do
# DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
# end
#
# after(:each) do
# DatabaseCleaner::ActiveRecord.connection_klasses = []
# end
#
# it "should finish a transaction" do
# connection.stub!(:decrement_open_transactions)
# another_connection.stub!(:decrement_open_transactions)
#
# connection.should_receive(:rollback_db_transaction)
# another_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)
#
# another_connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
# another_connection.stub!(:rollback_db_transaction)
#
# connection.should_receive(:decrement_open_transactions)
# another_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)
#
# another_connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
# another_connection.stub!(:rollback_db_transaction)
#
# ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
# model_klass.should_receive(:decrement_open_transactions)
# Transaction.new.clean
# end
end
end
end

137
spec/database_cleaner/active_record/truncation_spec.rb
View File

@ -15,7 +15,8 @@ module DatabaseCleaner
module ActiveRecord
describe Truncation do
let (:connection) { mock('connection') }
let (:connection) { mock('connection') }
before(:each) do
connection.stub!(:disable_referential_integrity).and_yield
@ -62,73 +63,73 @@ module DatabaseCleaner
end
end
context "multiple connection" do
let (:another_connection) { mock('another connection') }
let (:model_klass) { mock('klass') }
before(:each) do
another_connection.stub!(:disable_referential_integrity).and_yield
model_klass.stub!(:connection).and_return(another_connection)
DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
end
after(:each) do
DatabaseCleaner::ActiveRecord.connection_klasses = []
end
it "should truncate all tables except for schema_migrations on both connections" do
connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
another_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')
another_connection.should_receive(:truncate_table).with('widgets')
another_connection.should_receive(:truncate_table).with('dogs')
another_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])
another_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')
another_connection.should_receive(:truncate_table).with('widgets')
another_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])
another_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')
another_connection.should_receive(:truncate_table).with('dogs')
another_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
# context "multiple connection" do
#
# let (:another_connection) { mock('another connection') }
# let (:model_klass) { mock('klass') }
#
# before(:each) do
# another_connection.stub!(:disable_referential_integrity).and_yield
# model_klass.stub!(:connection).and_return(another_connection)
#
# DatabaseCleaner::ActiveRecord.connection_klasses = [model_klass]
# end
#
# after(:each) do
# DatabaseCleaner::ActiveRecord.connection_klasses = []
# end
#
# it "should truncate all tables except for schema_migrations on both connections" do
# connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
# another_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')
#
# another_connection.should_receive(:truncate_table).with('widgets')
# another_connection.should_receive(:truncate_table).with('dogs')
# another_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])
# another_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')
#
# another_connection.should_receive(:truncate_table).with('widgets')
# another_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])
# another_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')
#
# another_connection.should_receive(:truncate_table).with('dogs')
# another_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

14
spec/database_cleaner/base_spec.rb
View File

@ -95,6 +95,20 @@ module DatabaseCleaner
end
end
describe "db specification" do
it "should choose the default connection if none is specified" do
base = ::DatabaseCleaner::Base.new(:active_record)
base.db.should == :default
end
it "should accept connection as part of a hash of options" do
base = ::DatabaseCleaner::Base.new(:active_record,:connection => :my_db)
base.db.should == :my_db
end
it "should pass through db to the strategy"
end
describe "orm integration" do
let(:strategy) { mock("stratagem, attack all robots") }

60
spec/database_cleaner/configuration_spec.rb
View File

@ -7,26 +7,16 @@ module DatabaseCleaner
def reset
@connections = nil
end
def connections_stub!(array)
@connections = array
end
end
end
describe DatabaseCleaner do
before (:each) { ::DatabaseCleaner.reset }
describe ActiveRecord do
describe "connections" do
it "should return an array of classes containing ActiveRecord::Base by default" do
::DatabaseCleaner::ActiveRecord.connection_klasses.should == [::ActiveRecord::Base]
end
it "should merge in an array of classes to get connections from" do
model = mock("model")
::DatabaseCleaner::ActiveRecord.connection_klasses = [model]
::DatabaseCleaner::ActiveRecord.connection_klasses.should include model
::DatabaseCleaner::ActiveRecord.connection_klasses.should include ::ActiveRecord::Base
end
end
end
context "orm specification" do
it "should not accept unrecognised orms" do
lambda { ::DatabaseCleaner[nil] }.should raise_error ::DatabaseCleaner::NoORMDetected
@ -192,15 +182,41 @@ describe DatabaseCleaner do
# 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
let(:active_record_1) { mock("active_mock_on_db_one") }
let(:active_record_2) { mock("active_mock_on_db_two") }
let(:data_mapper_1) { mock("data_mock_on_db_one") }
it "should proxy orm to all connections and remove duplicate connections" do
pending
end
it "should proxy strategy to all connections and remove duplicate connections"
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")
::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 == 2
::DatabaseCleaner.strategy = strategy
::DatabaseCleaner.connections.size.should == 1
end
end
end

119
spec/database_cleaner/mongo_mapper/truncation_spec.rb
View File

@ -1,81 +1,84 @@
require File.dirname(__FILE__) + '/../../spec_helper'
require 'mongo_mapper'
require 'database_cleaner/mongo_mapper/truncation'
begin
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
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
class Widget
include MongoMapper::Document
key :name, String
end
class Gadget
include MongoMapper::Document
key :name, String
end
module DatabaseCleaner
module MongoMapper
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
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}"
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
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_widget(attrs={})
Widget.new({:name => 'some widget'}.merge(attrs)).save!
end
def create_gadget(attrs={})
Gadget.new({:name => 'some gadget'}.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
it "truncates all collections by default" 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)
Truncation.new.clean
ensure_counts(Widget => 0, Gadget => 0)
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)
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
rescue
end

5
spec/database_cleaner/shared_adaptor_spec.rb Normal file
View File

@ -0,0 +1,5 @@
shared_examples_for "database cleaner adaptor" do
it { should respond_to :db }
it { should respond_to :db= }
it { should respond_to :connection_klass }
end

28
spec/database_cleaner/strategy_base_spec.rb Normal file
View File

@ -0,0 +1,28 @@
require File.dirname(__FILE__) + '/../spec_helper'
require 'database_cleaner/strategy_base'
#require 'database_cleaner/active_record/transaction'
#require 'database_cleaner/data_mapper/transaction'
class ExampleStrategy
include ::DatabaseCleaner::StrategyBase
end
module DatabaseCleaner
describe StrategyBase do
context "upon inclusion" do
subject { ExampleStrategy.new }
it "should add the db setter method" do
should respond_to :db=
end
its(:db) { should == :default }
it "should store a symbol representing the db to use" do
subject.db = :my_specific_connection
subject.db.should == :my_specific_connection
end
end
end
end

2
spec/spec_helper.rb
View File

@ -1,7 +1,7 @@
require 'rubygems'
require 'spec'
require 'active_record'
require 'mongo_mapper'
#require 'mongo_mapper'
$:.unshift(File.dirname(__FILE__) + '/../lib')
require 'database_cleaner'