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

remove warning about == being ambiguous

This commit is contained in:
Jon Rowe 2013-08-20 14:58:17 +01:00
parent 70d221dcd1
commit da12d6134a
16 changed files with 130 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
spec/database_cleaner/active_record/base_spec.rb
View File

@ -19,7 +19,7 @@ module DatabaseCleaner
it "should default to DatabaseCleaner.root / config / database.yml" do
ActiveRecord.config_file_location=nil
DatabaseCleaner.should_receive(:app_root).and_return("/path/to")
subject.should == '/path/to/config/database.yml'
subject.should eq '/path/to/config/database.yml'
end
end
@ -45,11 +45,11 @@ module DatabaseCleaner
subject.stub(:load_config)
subject.db = :my_db
subject.db.should == :my_db
subject.db.should eq :my_db
end
it "should default to :default" do
subject.db.should == :default
subject.db.should eq :default
end
it "should load_config when I set db" do
@ -86,7 +86,7 @@ my_db:
it "should store the relevant config in connection_hash" do
subject.load_config
subject.connection_hash.should == { "database" => "one" }
subject.connection_hash.should eq( "database" => "one" )
end
it "should skip config if config file is not available" do
@ -115,14 +115,14 @@ my_db:
describe "connection_hash" do
it "should store connection_hash" do
subject.connection_hash = { :key => "value" }
subject.connection_hash.should == { :key => "value" }
subject.connection_hash.should eq( :key => "value" )
end
end
describe "connection_class" do
it { expect { subject.connection_class }.to_not raise_error }
it "should default to ActiveRecord::Base" do
subject.connection_class.should == ::ActiveRecord::Base
subject.connection_class.should eq ::ActiveRecord::Base
end
context "with database models" do
@ -131,14 +131,14 @@ my_db:
subject.db = FakeModel
subject.connection_hash = { }
subject.load_config
subject.connection_class.should == FakeModel
subject.connection_class.should eq FakeModel
end
end
context "connection_hash is not set" do
it "allows for database models to be passed in" do
subject.db = FakeModel
subject.connection_class.should == FakeModel
subject.connection_class.should eq FakeModel
end
end
end

4
spec/database_cleaner/active_record/truncation/mysql2_spec.rb
View File

@ -17,7 +17,7 @@ module ActiveRecord
2.times { User.create }
connection.truncate_table('users')
User.count.should == 0
User.count.should eq 0
end
it "should reset AUTO_INCREMENT index of table" do
@ -26,7 +26,7 @@ module ActiveRecord
connection.truncate_table('users')
User.create.id.should == 1
User.create.id.should eq 1
end
end

4
spec/database_cleaner/active_record/truncation/mysql_spec.rb
View File

@ -17,7 +17,7 @@ module ActiveRecord
2.times { User.create }
connection.truncate_table('users')
User.count.should == 0
User.count.should eq 0
end
it "should reset AUTO_INCREMENT index of table" do
@ -26,7 +26,7 @@ module ActiveRecord
connection.truncate_table('users')
User.create.id.should == 1
User.create.id.should eq 1
end
end

4
spec/database_cleaner/active_record/truncation/postgresql_spec.rb
View File

@ -24,7 +24,7 @@ module ActiveRecord
2.times { User.create }
connection.truncate_table('users')
User.count.should == 0
User.count.should eq 0
end
it "resets AUTO_INCREMENT index of table" do
@ -33,7 +33,7 @@ module ActiveRecord
connection.truncate_table('users')
User.create.id.should == 1
User.create.id.should eq 1
end
end

4
spec/database_cleaner/active_record/truncation/shared_fast_truncation.rb
View File

@ -14,7 +14,7 @@ shared_examples_for "an adapter with pre-count truncation" do
User.delete_all
connection.pre_count_truncate_tables(%w[users]) # true is also the default
User.create.id.should == 1
User.create.id.should eq 1
end
end
@ -33,7 +33,7 @@ shared_examples_for "an adapter with pre-count truncation" do
connection.pre_count_truncate_tables(%w[users], :reset_ids => false)
User.create.id.should == 3
User.create.id.should eq 3
end
end
end

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

@ -121,16 +121,16 @@ module DatabaseCleaner
end
subject { Truncation.new }
its(:pre_count?) { should == false }
its(:pre_count?) { should eq false }
it 'should return true if @reset_id is set and non false or nil' do
subject.instance_variable_set(:"@pre_count", true)
subject.send(:pre_count?).should == true
subject.send(:pre_count?).should eq true
end
it 'should return false if @reset_id is set to false' do
subject.instance_variable_set(:"@pre_count", false)
subject.send(:pre_count?).should == false
subject.send(:pre_count?).should eq false
end
end
@ -142,16 +142,16 @@ module DatabaseCleaner
end
subject { Truncation.new }
its(:reset_ids?) { should == true }
its(:reset_ids?) { should eq true }
it 'should return true if @reset_id is set and non false or nil' do
subject.instance_variable_set(:"@reset_ids", 'Something')
subject.send(:reset_ids?).should == true
subject.send(:reset_ids?).should eq true
end
it 'should return false if @reset_id is set to false' do
subject.instance_variable_set(:"@reset_ids", false)
subject.send(:reset_ids?).should == false
subject.send(:reset_ids?).should eq false
end
end
end

56
spec/database_cleaner/base_spec.rb
View File

@ -77,7 +77,7 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :active_record
cleaner.orm.should eq :active_record
cleaner.should be_auto_detected
end
@ -91,7 +91,7 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :data_mapper
cleaner.orm.should eq :data_mapper
cleaner.should be_auto_detected
end
@ -104,7 +104,7 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :mongo_mapper
cleaner.orm.should eq :mongo_mapper
cleaner.should be_auto_detected
end
@ -116,7 +116,7 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :mongoid
cleaner.orm.should eq :mongoid
cleaner.should be_auto_detected
end
@ -127,7 +127,7 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :couch_potato
cleaner.orm.should eq :couch_potato
cleaner.should be_auto_detected
end
@ -137,7 +137,7 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :sequel
cleaner.orm.should eq :sequel
cleaner.should be_auto_detected
end
@ -145,21 +145,21 @@ module DatabaseCleaner
Object.const_set('Ohm', 'Ohm mock')
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :ohm
cleaner.orm.should eq :ohm
cleaner.should be_auto_detected
end
it 'detects Redis last' do
Object.const_set('Redis', 'Redis mock')
cleaner.orm.should == :redis
cleaner.orm.should eq :redis
cleaner.should be_auto_detected
end
it 'detects Moped seventh' do
Object.const_set('Moped', 'Moped mock')
cleaner.orm.should == :moped
cleaner.orm.should eq :moped
cleaner.should be_auto_detected
end
end
@ -174,7 +174,7 @@ module DatabaseCleaner
::DatabaseCleaner.should_receive(:orm_module).with(orm).and_return(mockule)
cleaner.send(:orm_module).should == mockule
cleaner.send(:orm_module).should eq mockule
end
end
@ -188,8 +188,8 @@ module DatabaseCleaner
two = DatabaseCleaner::Base.new(:active_record,:connection => :default)
two.strategy = strategy
one.should == two
two.should == one
one.should eq two
two.should eq one
end
end
@ -198,19 +198,19 @@ module DatabaseCleaner
subject { ::DatabaseCleaner::Base.new(:active_record,:connection => :my_db) }
it "should store db from :connection in params hash" do
subject.db.should == :my_db
subject.db.should eq :my_db
end
end
describe "orm" do
it "should store orm" do
cleaner = ::DatabaseCleaner::Base.new :a_orm
cleaner.orm.should == :a_orm
cleaner.orm.should eq :a_orm
end
it "converts string to symbols" do
cleaner = ::DatabaseCleaner::Base.new "mongoid"
cleaner.orm.should == :mongoid
cleaner.orm.should eq :mongoid
end
it "is autodetected if orm is not provided" do
@ -231,13 +231,13 @@ module DatabaseCleaner
describe "db" do
it "should default to :default" do
subject.db.should == :default
subject.db.should eq :default
end
it "should return any stored db value" do
subject.stub(:strategy_db=)
subject.db = :test_db
subject.db.should == :test_db
subject.db.should eq :test_db
end
it "should pass db to any specified strategy" do
@ -301,7 +301,7 @@ module DatabaseCleaner
end
it "should return the strategy" do
subject.clean_with( :strategy ).should == strategy
subject.clean_with( :strategy ).should eq strategy
end
end
@ -321,7 +321,7 @@ module DatabaseCleaner
end
it "should return the strategy" do
subject.clean_with!( :strategy ).should == strategy
subject.clean_with!( :strategy ).should eq strategy
end
end
@ -342,7 +342,7 @@ module DatabaseCleaner
subject.create_strategy :strategy, {:params => {:lorum => "ipsum"}}
end
it "should return the resulting strategy" do
subject.create_strategy( :strategy ).should == strategy_class.new
subject.create_strategy( :strategy ).should eq strategy_class.new
end
end
@ -375,7 +375,7 @@ module DatabaseCleaner
it "should return the stored strategy" do
result = subject.strategy = mock_strategy
result.should == mock_strategy
result.should eq mock_strategy
end
end
@ -383,21 +383,21 @@ module DatabaseCleaner
subject { ::DatabaseCleaner::Base.new :a_orm }
it "returns a null strategy when strategy is not set and undetectable" do
subject.strategy.should == DatabaseCleaner::NullStrategy
subject.strategy.should eq DatabaseCleaner::NullStrategy
end
it "returns the set strategy" do
strategum = double("strategy")
subject.strategy = strategum
subject.strategy.should == strategum
subject.strategy.should eq strategum
end
end
describe "orm=" do
it "should stored the desired orm" do
subject.orm.should_not == :desired_orm
subject.orm.should_not eq :desired_orm
subject.orm = :desired_orm
subject.orm.should == :desired_orm
subject.orm.should eq :desired_orm
end
end
@ -406,7 +406,7 @@ module DatabaseCleaner
it "should return orm if orm set" do
subject.instance_variable_set "@orm", mock_orm
subject.orm.should == mock_orm
subject.orm.should eq mock_orm
end
context "orm isn't set" do
@ -419,7 +419,7 @@ module DatabaseCleaner
it "should return the result of autodetect if orm isn't set" do
subject.stub(:autodetect).and_return(mock_orm)
subject.orm.should == mock_orm
subject.orm.should eq mock_orm
end
end
end
@ -508,7 +508,7 @@ module DatabaseCleaner
strategy_class.should_receive(:const_get).with("Cunningplan").and_return(strategy_strategy_class)
subject.send(:orm_strategy, :cunningplan).should == strategy_strategy_class
subject.send(:orm_strategy, :cunningplan).should eq strategy_strategy_class
end
end

92
spec/database_cleaner/configuration_spec.rb
View File

@ -31,70 +31,70 @@ 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
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 == :data_mapper
::DatabaseCleaner.connections.size.should == 1
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 == :mongo_mapper
::DatabaseCleaner.connections.size.should == 1
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 == :couch_potato
::DatabaseCleaner.connections.size.should == 1
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 == :moped
::DatabaseCleaner.connections.size.should == 1
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 == :ohm
::DatabaseCleaner.connections.size.should == 1
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 == 2
::DatabaseCleaner.connections[0].orm.should == :couch_potato
::DatabaseCleaner.connections[1].orm.should == :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 == :active_record
cleaner.db.should == :first_connection
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 == 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
::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
@ -103,19 +103,19 @@ describe ::DatabaseCleaner do
::DatabaseCleaner[:active_record,{:connection => :first_db} ]
::DatabaseCleaner[:data_mapper, {:connection => :second_db}]
::DatabaseCleaner.connections.size.should == 4
::DatabaseCleaner.connections.size.should eq 4
::DatabaseCleaner.connections[0].orm.should == :data_mapper
::DatabaseCleaner.connections[0].db.should == :first_db
::DatabaseCleaner.connections[0].orm.should eq :data_mapper
::DatabaseCleaner.connections[0].db.should eq :first_db
::DatabaseCleaner.connections[1].orm.should == :active_record
::DatabaseCleaner.connections[1].db.should == :second_db
::DatabaseCleaner.connections[1].orm.should eq :active_record
::DatabaseCleaner.connections[1].db.should eq :second_db
::DatabaseCleaner.connections[2].orm.should == :active_record
::DatabaseCleaner.connections[2].db.should == :first_db
::DatabaseCleaner.connections[2].orm.should eq :active_record
::DatabaseCleaner.connections[2].db.should eq :first_db
::DatabaseCleaner.connections[3].orm.should == :data_mapper
::DatabaseCleaner.connections[3].db.should == :second_db
::DatabaseCleaner.connections[3].orm.should eq :data_mapper
::DatabaseCleaner.connections[3].db.should eq :second_db
end
end
@ -123,7 +123,7 @@ describe ::DatabaseCleaner 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
::DatabaseCleaner[:active_record].should eq connection
end
end
@ -134,7 +134,7 @@ describe ::DatabaseCleaner do
cleaner = double("cleaner").as_null_object
::DatabaseCleaner::Base.stub(:new).and_return(cleaner)
::DatabaseCleaner.connections.should == [cleaner]
::DatabaseCleaner.connections.should eq [cleaner]
end
end
@ -229,9 +229,9 @@ describe ::DatabaseCleaner do
active_record_1.should_receive(:==).with(data_mapper_1).and_return(true)
::DatabaseCleaner.connections.size.should == 3
::DatabaseCleaner.connections.size.should eq 3
::DatabaseCleaner.orm = :data_mapper
::DatabaseCleaner.connections.size.should == 2
::DatabaseCleaner.connections.size.should eq 2
end
it "should proxy strategy to all connections and remove duplicate connections" do
@ -246,9 +246,9 @@ describe ::DatabaseCleaner do
active_record_1.should_receive(:==).with(active_record_2).and_return(true)
::DatabaseCleaner.connections.size.should == 2
::DatabaseCleaner.connections.size.should eq 2
::DatabaseCleaner.strategy = strategy
::DatabaseCleaner.connections.size.should == 1
::DatabaseCleaner.connections.size.should eq 1
end
end
end
@ -261,18 +261,18 @@ describe ::DatabaseCleaner do
::DatabaseCleaner.connections_stub [connection,connection,connection]
::DatabaseCleaner.remove_duplicates
::DatabaseCleaner.connections.size.should == 1
::DatabaseCleaner.connections.size.should eq 1
end
end
describe "app_root" do
it "should default to Dir.pwd" do
DatabaseCleaner.app_root.should == Dir.pwd
DatabaseCleaner.app_root.should eq Dir.pwd
end
it "should store specific paths" do
DatabaseCleaner.app_root = '/path/to'
DatabaseCleaner.app_root.should == '/path/to'
DatabaseCleaner.app_root.should eq '/path/to'
end
end
@ -281,32 +281,32 @@ describe ::DatabaseCleaner do
it "should return DatabaseCleaner::ActiveRecord for :active_record" do
::DatabaseCleaner::ActiveRecord = double("ar module") unless defined? ::DatabaseCleaner::ActiveRecord
subject.orm_module(:active_record).should == 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 == 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 == 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 == 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 == 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 == DatabaseCleaner::CouchPotato
subject.orm_module(:couch_potato).should eq DatabaseCleaner::CouchPotato
end
end

4
spec/database_cleaner/data_mapper/base_spec.rb
View File

@ -19,11 +19,11 @@ module DatabaseCleaner
it "should store my desired db" do
subject.db = :my_db
subject.db.should == :my_db
subject.db.should eq :my_db
end
it "should default to :default" do
subject.db.should == :default
subject.db.should eq :default
end
end
end

2
spec/database_cleaner/generic/base_spec.rb
View File

@ -16,7 +16,7 @@ module ::DatabaseCleaner
it_should_behave_like "a generic strategy"
its(:db) { should == :default }
its(:db) { should eq :default }
end
end
end

18
spec/database_cleaner/generic/truncation_spec.rb
View File

@ -57,40 +57,40 @@ module ::DatabaseCleaner
context "" do
subject { TruncationExample.new( { :only => ["something"] } ) }
its(:only) { should == ["something"] }
its(:except) { should == [] }
its(:only) { should eq ["something"] }
its(:except) { should eq [] }
end
context "" do
subject { TruncationExample.new( { :except => ["something"] } ) }
its(:only) { should == nil }
its(:only) { should eq nil }
its(:except) { should include("something") }
end
context "" do
subject { TruncationExample.new( { :reset_ids => ["something"] } ) }
its(:reset_ids?) { should == true }
its(:reset_ids?) { should eq true }
end
context "" do
subject { TruncationExample.new( { :reset_ids => nil } ) }
its(:reset_ids?) { should == false }
its(:reset_ids?) { should eq false }
end
context "" do
subject { TruncationExample.new( { :pre_count => ["something"] } ) }
its(:pre_count?) { should == true }
its(:pre_count?) { should eq true }
end
context "" do
subject { TruncationExample.new( { :pre_count => nil } ) }
its(:pre_count?) { should == false }
its(:pre_count?) { should eq false }
end
context "" do
subject { MigrationExample.new }
its(:only) { should == nil }
its(:except) { should == %w[migration_storage_name] }
its(:only) { should eq nil }
its(:except) { should eq %w[migration_storage_name] }
end
context "" do

4
spec/database_cleaner/mongo_mapper/base_spec.rb
View File

@ -21,11 +21,11 @@ module DatabaseCleaner
it "should store my desired db" do
subject.db = :my_db
subject.db.should == :my_db
subject.db.should eq :my_db
end
it "should default to :default" do
subject.db.should == :default
subject.db.should eq :default
end
end
end

16
spec/database_cleaner/ohm/truncation_spec.rb
View File

@ -39,19 +39,19 @@ module DatabaseCleaner
it "truncates all keys by default" do
create_widget
create_gadget
@redis.keys.size.should == 6
@redis.keys.size.should eq 6
Truncation.new.clean
@redis.keys.size.should == 0
@redis.keys.size.should eq 0
end
context "when keys are provided to the :only option" do
it "only truncates the specified keys" do
create_widget
create_gadget
@redis.keys.size.should == 6
@redis.keys.size.should eq 6
Truncation.new(:only => ['*Widget*']).clean
@redis.keys.size.should == 3
@redis.get('DatabaseCleaner::Ohm::Gadget:id').should == '1'
@redis.keys.size.should eq 3
@redis.get('DatabaseCleaner::Ohm::Gadget:id').should eq '1'
end
end
@ -59,10 +59,10 @@ module DatabaseCleaner
it "truncates all but the specified keys" do
create_widget
create_gadget
@redis.keys.size.should == 6
@redis.keys.size.should eq 6
Truncation.new(:except => ['*Widget*']).clean
@redis.keys.size.should == 3
@redis.get('DatabaseCleaner::Ohm::Widget:id').should == '1'
@redis.keys.size.should eq 3
@redis.get('DatabaseCleaner::Ohm::Widget:id').should eq '1'
end
end
end

4
spec/database_cleaner/redis/base_spec.rb
View File

@ -21,11 +21,11 @@ module DatabaseCleaner
it "should store my describe db" do
url = 'redis://localhost:6379/2'
subject.db = 'redis://localhost:6379/2'
subject.db.should == url
subject.db.should eq url
end
it "should default to :default" do
subject.db.should == :default
subject.db.should eq :default
end
end
end

16
spec/database_cleaner/redis/truncation_spec.rb
View File

@ -31,19 +31,19 @@ module DatabaseCleaner
it "truncates all keys by default" do
create_widget
create_gadget
@redis.keys.size.should == 2
@redis.keys.size.should eq 2
Truncation.new.clean
@redis.keys.size.should == 0
@redis.keys.size.should eq 0
end
context "when keys are provided to the :only option" do
it "only truncates the specified keys" do
create_widget
create_gadget
@redis.keys.size.should == 2
@redis.keys.size.should eq 2
Truncation.new(:only => ['Widge*']).clean
@redis.keys.size.should == 1
@redis.get('Gadget').should == '1'
@redis.keys.size.should eq 1
@redis.get('Gadget').should eq '1'
end
end
@ -51,10 +51,10 @@ module DatabaseCleaner
it "truncates all but the specified keys" do
create_widget
create_gadget
@redis.keys.size.should == 2
@redis.keys.size.should eq 2
Truncation.new(:except => ['Widg*']).clean
@redis.keys.size.should == 1
@redis.get('Widget').should == '1'
@redis.keys.size.should eq 1
@redis.get('Widget').should eq '1'
end
end
end

4
spec/database_cleaner/sequel/base_spec.rb
View File

@ -20,12 +20,12 @@ module DatabaseCleaner
it "should store my desired db" do
subject.db = :my_db
subject.db.should == :my_db
subject.db.should eq :my_db
end
it "should default to :default" do
pending "I figure out how to use Sequel and write some real tests for it..."
subject.db.should == :default
subject.db.should eq :default
end
end
end