| ORM | Truncation | Transaction | Deletion |
|---|---|---|---|
| ActiveRecord | Yes | Yes | Yes |
| DataMapper | Yes | Yes | No |
| CouchPotato | Yes | No | No |
| MongoMapper | Yes | No | No |
| Mongoid | Yes | No | No |
| Sequel | Yes | Yes | Yes |
| Redis | Yes | No | No |
| Ohm | Yes | No | No |
| Neo4j | Yes | Yes* | Yes* |
| Driver | Truncation | Transaction | Deletion |
|---|---|---|---|
| Mongo | Yes | No | No |
| Moped | Yes | No | No |
| ORM | How to access | Notes |
|---|---|---|
| Active Record | DatabaseCleaner[:active_record] |
Connection specified as :symbol keys, loaded from config/database.yml. You may also pass in the ActiveRecord model under the :model key. |
| Data Mapper | DatabaseCleaner[:data_mapper] |
Connection specified as :symbol keys, loaded via Datamapper repositories |
| Mongo Mapper | DatabaseCleaner[:mongo_mapper] |
Multiple connections not yet supported |
| Mongoid | DatabaseCleaner[:mongoid] |
Multiple databases supported for Mongoid 3. Specify DatabaseCleaner[:mongoid, {:connection => :db_name}] |
| Moped | DatabaseCleaner[:moped] |
It is necessary to configure database name with DatabaseCleaner[:moped].db = db_name otherwise name `default` will be used. |
| Couch Potato | DatabaseCleaner[:couch_potato] |
Multiple connections not yet supported |
| Sequel | DatabaseCleaner[:sequel] |
Multiple databases supported; specify DatabaseCleaner[:sequel, {:connection => Sequel.connect(uri)}] |
| Redis | DatabaseCleaner[:redis] |
Connection specified as Redis URI |
| Ohm | DatabaseCleaner[:ohm] |
Connection specified as Redis URI |
| Neo4j | DatabaseCleaner[:neo4j] |
Database type and path(URI) DatabaseCleaner[:neo4j, connection: {type: :server_db, path: 'http://localhost:7475'}]. |
test: adapter: postgresql # ... min_messages: WARNING### Nothing happens in JRuby with Sequel using transactions Due to an inconsistency in JRuby's implementation of Fibers, Sequel gives a different connection to `DatabaseCleaner.start` than is used for tests run between `.start` and `.clean`. This can be worked around by running your tests in a block like `DatabaseCleaner.cleaning { run_my_tests }` instead, which does not use Fibers. ### Model fails to load with Neo4j using transactions When you are using [neo4j](https://github.com/neo4jrb/neo4j) gem it creates schema and reads indexes upon loading models. These operations can't be done during a transaction. You have to preload your models before DatabaseCleaner starts a transaction. Add to your rails_helper or spec_helper after requiring database_cleaner: ```ruby require 'database_cleaner' Dir["#{Rails.root}/app/models/**/*.rb"].each do |model| load model end ``` ## Safeguards DatabaseCleaner comes with safeguards against: * Running in production (checking for `ENV`, `RACK_ENV`, and `RAILS_ENV`) * Running against a remote database (checking for a `DATABASE_URL` that does not include `localhost`) Both safeguards can be disabled separately as follows. Using environment variables: ``` export DATABASE_CLEANER_ALLOW_PRODUCTION=true export DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL=true ``` In Ruby: ```ruby DatabaseCleaner.allow_production = true DatabaseCleaner.allow_remote_database_url = true ``` ## Debugging In rare cases DatabaseCleaner will encounter errors that it will log. By default it uses STDOUT set to the ERROR level but you can configure this to use whatever Logger you desire. Here's an example of using the `Rails.logger` in `env.rb`: ```ruby DatabaseCleaner.logger = Rails.logger ``` ## COPYRIGHT Copyright (c) 2014 Ben Mabey. See LICENSE for details. database_cleaner-1.7.0/Rakefile 0000664 0000000 0000000 00000002107 13266175307 0016433 0 ustar 00root root 0000000 0000000 require "rubygems" require "bundler" Bundler.setup require 'rake' require 'rspec/core' require 'rspec/core/rake_task' RSpec::Core::RakeTask.new(:spec) do |spec| spec.pattern = FileList['spec/**/*_spec.rb'] end RSpec::Core::RakeTask.new(:rcov) do |spec| spec.pattern = 'spec/**/*_spec.rb' spec.rcov = true end begin require 'cucumber/rake/task' Cucumber::Rake::Task.new(:features) rescue LoadError puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber" end task :default => [:spec, :features] desc "Cleans the project of any tmp file that should not be included in the gemspec." task :clean do ["examples/config/database.yml", "examples/db/activerecord_one.db", "examples/db/activerecord_two.db", "examples/db/datamapper_default.db", "examples/db/datamapper_one.db", "examples/db/datamapper_two.db"].each do |f| FileUtils.rm_f(f) end %w[*.sqlite3 *.log #* *.swp *.swo].each do |pattern| `find . -name "#{pattern}" -delete` end end desc "Cleans the dir and builds the gem" task :prep => [:clean, :gemspec, :build] database_cleaner-1.7.0/TODO 0000664 0000000 0000000 00000000124 13266175307 0015453 0 ustar 00root root 0000000 0000000 Could be more Datamapper MongoMapper multiple db support CouchDB multiple db support database_cleaner-1.7.0/VERSION.yml 0000664 0000000 0000000 00000000042 13266175307 0016632 0 ustar 00root root 0000000 0000000 --- :major: 1 :minor: 7 :patch: 0 database_cleaner-1.7.0/cucumber.yml 0000664 0000000 0000000 00000000022 13266175307 0017310 0 ustar 00root root 0000000 0000000 default: features database_cleaner-1.7.0/database_cleaner.gemspec 0000664 0000000 0000000 00000004644 13266175307 0021600 0 ustar 00root root 0000000 0000000 require 'yaml' version = YAML.load_file 'VERSION.yml' Gem::Specification.new do |s| s.name = "database_cleaner" s.version = "#{version[:major]}.#{version[:minor]}.#{version[:patch]}" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.required_ruby_version = ">= 1.9.3" s.require_paths = ["lib"] s.authors = ["Ben Mabey", "Ernesto Tagwerker"] s.description = "Strategies for cleaning databases. Can be used to ensure a clean state for testing." s.email = "ernesto@ombulabs.com" s.extra_rdoc_files = [ "LICENSE", "README.markdown", "TODO" ] s.files = [ "CONTRIBUTE.markdown", "Gemfile.lock", "History.rdoc", "README.markdown", "Rakefile", "VERSION.yml", "cucumber.yml"] s.files += Dir['lib/**/*.rb'] s.homepage = "http://github.com/DatabaseCleaner/database_cleaner" s.license = 'MIT' s.rubygems_version = "2.4.5" s.summary = "Strategies for cleaning databases. Can be used to ensure a clean state for testing." s.add_development_dependency "rake" s.add_development_dependency "bundler" s.add_development_dependency "json_pure" s.add_development_dependency "activerecord-mysql2-adapter" unless RUBY_PLATFORM =~ /java/ s.add_development_dependency "activerecord" s.add_development_dependency "datamapper" s.add_development_dependency "dm-migrations" s.add_development_dependency "dm-sqlite-adapter" s.add_development_dependency "mongoid" s.add_development_dependency "tzinfo" s.add_development_dependency "mongoid-tree" s.add_development_dependency "mongo_mapper" s.add_development_dependency "moped" s.add_development_dependency "neo4j-core" s.add_development_dependency "couch_potato" s.add_development_dependency "sequel", "~> 3.21.0" s.add_development_dependency 'ohm', '~> 0.1.3' s.add_development_dependency 'guard-rspec' s.add_development_dependency "rspec-rails", "~> 2.14.2" s.add_development_dependency "cucumber" unless RUBY_PLATFORM =~ /java/ s.add_development_dependency "mongo_ext" s.add_development_dependency "bson_ext" s.add_development_dependency 'mysql', '~> 2.9.1' s.add_development_dependency 'mysql2' s.add_development_dependency 'pg' s.add_development_dependency "sqlite3-ruby" if RUBY_VERSION < "1.9" s.add_development_dependency "sqlite3" if RUBY_VERSION >= "1.9" else s.add_development_dependency "activerecord-jdbc-adapter" end end database_cleaner-1.7.0/db/ 0000775 0000000 0000000 00000000000 13266175307 0015353 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/db/sample.config.yml 0000664 0000000 0000000 00000001004 13266175307 0020616 0 ustar 00root root 0000000 0000000 mysql: adapter: mysql database: database_cleaner_test username: root password: host: 127.0.0.1 port: 3306 encoding: utf8 mysql2: adapter: mysql2 database: database_cleaner_test username: root password: host: 127.0.0.1 port: 3306 encoding: utf8 postgres: adapter: postgresql database: database_cleaner_test username: postgres password: host: 127.0.0.1 encoding: unicode template: template0 sqlite3: adapter: sqlite3 database: db/test.sqlite3 pool: 5 timeout: 5000 database_cleaner-1.7.0/examples/ 0000775 0000000 0000000 00000000000 13266175307 0016604 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/Gemfile 0000777 0000000 0000000 00000000000 13266175307 0021600 2../Gemfile ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/Gemfile.lock 0000777 0000000 0000000 00000000000 13266175307 0023456 2../Gemfile.lock ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/config/ 0000775 0000000 0000000 00000000000 13266175307 0020051 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/config/database.yml.example 0000664 0000000 0000000 00000000600 13266175307 0023766 0 ustar 00root root 0000000 0000000 #This is an example of what database.yml *should* look like (when I wrote it) #The real database.yml is generated automatically by the active record model lib (so it can be correct) two: adapter: sqlite3 database: /path/to/examples/features/support/../../db/activerecord_two.db one: adapter: sqlite3 database: /path/to/examples/features/support/../../db/activerecord_one.db database_cleaner-1.7.0/examples/config/redis.yml 0000664 0000000 0000000 00000000170 13266175307 0021700 0 ustar 00root root 0000000 0000000 test: url: 'redis://localhost:6379/0' one: url: 'redis://localhost:6379/1' two: url: 'redis://localhost:6379/2' database_cleaner-1.7.0/examples/db/ 0000775 0000000 0000000 00000000000 13266175307 0017171 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/db/sqlite_databases_go_here 0000664 0000000 0000000 00000000000 13266175307 0024102 0 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/features/ 0000775 0000000 0000000 00000000000 13266175307 0020422 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/features/example.feature 0000664 0000000 0000000 00000000433 13266175307 0023432 0 ustar 00root root 0000000 0000000 Feature: example In order to test DataBase Cleaner Here are some scenarios that rely on the DB being clean! Scenario: dirty the db When I create a widget Then I should see 1 widget Scenario: assume a clean db When I create a widget Then I should see 1 widget database_cleaner-1.7.0/examples/features/example_multiple_db.feature 0000664 0000000 0000000 00000001276 13266175307 0026020 0 ustar 00root root 0000000 0000000 Feature: example In order to test DataBase Cleaner Here are some scenarios that rely on the DB being clean! # Background: # Given I have setup DatabaseCleaner to clean multiple databases # Scenario: dirty the db When I create a widget in one db And I create a widget in another db Then I should see 1 widget in one db And I should see 1 widget in another db Scenario: assume a clean db When I create a widget in one db Then I should see 1 widget in one db And I should see 0 widget in another db Scenario: assume a clean db When I create a widget in another db Then I should see 0 widget in one db And I should see 1 widget in another db database_cleaner-1.7.0/examples/features/example_multiple_orm.feature 0000664 0000000 0000000 00000001275 13266175307 0026227 0 ustar 00root root 0000000 0000000 Feature: example In order to test DataBase Cleaner Here are some scenarios that rely on the DB being clean! # Background: # Given I have setup DatabaseCleaner to clean multiple orms Scenario: dirty the db When I create a widget in one orm And I create a widget in another orm Then I should see 1 widget in one orm And I should see 1 widget in another orm Scenario: assume a clean db When I create a widget in one orm Then I should see 1 widget in one orm And I should see 0 widget in another orm Scenario: assume a clean db When I create a widget in another orm Then I should see 0 widget in one orm And I should see 1 widget in another orm database_cleaner-1.7.0/examples/features/step_definitions/ 0000775 0000000 0000000 00000000000 13266175307 0023770 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/features/step_definitions/activerecord_steps.rb 0000664 0000000 0000000 00000002127 13266175307 0030207 0 ustar 00root root 0000000 0000000 Given /^I have setup database cleaner to clean multiple databases using activerecord$/ do #DatabaseCleaner # require "#{File.dirname(__FILE__)}/../../../lib/datamapper_models" # # DatabaseCleaner[:datamapper, {:connection => :one} ].strategy = :truncation # DatabaseCleaner[:datamapper, {:connection => :two} ].strategy = :truncation end When /^I create a widget using activerecord$/ do ActiveRecordWidget.create! end Then /^I should see ([\d]+) widget using activerecord$/ do |widget_count| ActiveRecordWidget.count.should == widget_count.to_i end When /^I create a widget in one db using activerecord$/ do ActiveRecordWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using activerecord$/ do ActiveRecordWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using activerecord$/ do |widget_count| ActiveRecordWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using activerecord$/ do |widget_count| ActiveRecordWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/couchpotato_steps.rb 0000664 0000000 0000000 00000002115 13266175307 0030062 0 ustar 00root root 0000000 0000000 Given /^I have setup database cleaner to clean multiple databases using couchpotato$/ do #DatabaseCleaner # require "#{File.dirname(__FILE__)}/../../../lib/couchpotato_models" # # DatabaseCleaner[:couchpotato, {:connection => :one} ].strategy = :truncation # DatabaseCleaner[:couchpotato, {:connection => :two} ].strategy = :truncation end When /^I create a widget using couchpotato$/ do CouchPotatoWidget.create! end Then /^I should see ([\d]+) widget using couchpotato$/ do |widget_count| CouchPotatoWidget.count.should == widget_count.to_i end When /^I create a widget in one db using couchpotato$/ do CouchPotatoWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using couchpotato$/ do CouchPotatoWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using couchpotato$/ do |widget_count| CouchPotatoWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using couchpotato$/ do |widget_count| CouchPotatoWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/datamapper_steps.rb 0000664 0000000 0000000 00000002273 13266175307 0027655 0 ustar 00root root 0000000 0000000 Given /^I have setup database cleaner to clean multiple databases using datamapper$/ do #DatabaseCleaner # require "#{File.dirname(__FILE__)}/../../../lib/datamapper_models" # # DatabaseCleaner[:datamapper, {:connection => :one} ].strategy = :truncation # DatabaseCleaner[:datamapper, {:connection => :two} ].strategy = :truncation end When /^I create a widget using datamapper$/ do DataMapperWidget.create! end Then /^I should see ([\d]+) widget using datamapper$/ do |widget_count| DataMapperWidget.count.should == widget_count.to_i end When /^I create a widget in one db using datamapper$/ do begin DataMapperWidgetUsingDatabaseOne.create! rescue StandardError => e BREAK = e.backtrace debugger DataMapperWidgetUsingDatabaseOne.create! end end When /^I create a widget in another db using datamapper$/ do DataMapperWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using datamapper$/ do |widget_count| DataMapperWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using datamapper$/ do |widget_count| DataMapperWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/mongoid_steps.rb 0000664 0000000 0000000 00000001327 13266175307 0027172 0 ustar 00root root 0000000 0000000 When /^I create a widget using mongoid$/ do MongoidWidget.create!( :id => rand(1000)+1000) end Then /^I should see ([\d]+) widget using mongoid$/ do |widget_count| MongoidWidget.count.should == widget_count.to_i end When /^I create a widget in one db using mongoid$/ do MongoidWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using mongoid$/ do MongoidWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using mongoid$/ do |widget_count| MongoidWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using mongoid$/ do |widget_count| MongoidWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/mongomapper_steps.rb 0000664 0000000 0000000 00000002112 13266175307 0030053 0 ustar 00root root 0000000 0000000 Given /^I have setup database cleaner to clean multiple databases using mongomapper$/ do #DatabaseCleaner # require "#{File.dirname(__FILE__)}/../../../lib/datamapper_models" # # DatabaseCleaner[:datamapper, {:connection => :one} ].strategy = :truncation # DatabaseCleaner[:datamapper, {:connection => :two} ].strategy = :truncation end When /^I create a widget using mongomapper$/ do MongoMapperWidget.create! end Then /^I should see ([\d]+) widget using mongomapper$/ do |widget_count| MongoMapperWidget.count.should == widget_count.to_i end When /^I create a widget in one db using mongomapper$/ do MongoMapperWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using mongomapper$/ do MongoMapperWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using mongomapper$/ do |widget_count| MongoMapperWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using mongomapper$/ do |widget_count| MongoMapperWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/neo4j_steps.rb 0000664 0000000 0000000 00000001246 13266175307 0026555 0 ustar 00root root 0000000 0000000 When /^I create a widget using neo4j$/ do Neo4jWidget.create! end Then /^I should see ([\d]+) widget using neo4j$/ do |widget_count| Neo4jWidget.count.should == widget_count.to_i end When /^I create a widget in one db using neo4j$/ do Neo4jWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using neo4j$/ do Neo4jWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using neo4j$/ do |widget_count| Neo4jWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using neo4j$/ do |widget_count| Neo4jWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/ohm_steps.rb 0000664 0000000 0000000 00000001755 13266175307 0026326 0 ustar 00root root 0000000 0000000 Given /^I have setup database cleaner to clean multiple databases using ohm$/ do #DatabaseCleaner # require "#{File.dirname(__FILE__)}/../../../lib/ohm_models" # # DatabaseCleaner[:ohm, {:connection => ENV['REDIS_URL_ONE']} ].strategy = :truncation # DatabaseCleaner[:ohm, {:connection => ENV['REDIS_URL_TWO']} ].strategy = :truncation end When /^I create a widget using ohm$/ do OhmWidget.create! end Then /^I should see ([\d]+) widget using ohm$/ do |widget_count| OhmWidget.count.should == widget_count.to_i end When /^I create a widget in one db using ohm$/ do OhmWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using ohm$/ do OhmWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using ohm$/ do |widget_count| OhmWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using ohm$/ do |widget_count| OhmWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/redis_steps.rb 0000664 0000000 0000000 00000002015 13266175307 0026637 0 ustar 00root root 0000000 0000000 Given /^I have setup database cleaner to clean multiple databases using redis$/ do #DatabaseCleaner # require "#{File.dirname(__FILE__)}/../../../lib/redis_models" # # DatabaseCleaner[:redis, {:connection => ENV['REDIS_URL_ONE']} ].strategy = :truncation # DatabaseCleaner[:redis, {:connection => ENV['REDIS_URL_TWO']} ].strategy = :truncation end When /^I create a widget using redis$/ do RedisWidget.create! end Then /^I should see ([\d]+) widget using redis$/ do |widget_count| RedisWidget.count.should == widget_count.to_i end When /^I create a widget in one db using redis$/ do RedisWidgetUsingDatabaseOne.create! end When /^I create a widget in another db using redis$/ do RedisWidgetUsingDatabaseTwo.create! end Then /^I should see ([\d]+) widget in one db using redis$/ do |widget_count| RedisWidgetUsingDatabaseOne.count.should == widget_count.to_i end Then /^I should see ([\d]+) widget in another db using redis$/ do |widget_count| RedisWidgetUsingDatabaseTwo.count.should == widget_count.to_i end database_cleaner-1.7.0/examples/features/step_definitions/translation_steps.rb 0000664 0000000 0000000 00000003067 13266175307 0030077 0 ustar 00root root 0000000 0000000 When /^I create a widget$/ do step "I create a widget using #{ENV['ORM'].downcase}" end Then /^I should see 1 widget$/ do step "I should see 1 widget using #{ENV['ORM'].downcase}" end When /^I create a widget in one orm$/ do step "I create a widget using #{ENV['ORM'].downcase}" end When /^I create a widget in another orm$/ do step "I create a widget using #{ENV['ANOTHER_ORM'].downcase}" end Then /^I should see 1 widget in one orm$/ do step "I should see 1 widget using #{ENV['ORM'].downcase}" end Then /^I should see 1 widget in another orm$/ do step "I should see 1 widget using #{ENV['ANOTHER_ORM'].downcase}" end Then /^I should see 0 widget in another orm$/ do step "I should see 0 widget using #{ENV['ANOTHER_ORM'].downcase}" end Then /^I should see 0 widget in one orm$/ do step "I should see 0 widget using #{ENV['ORM'].downcase}" end When /^I create a widget in one db$/ do step "I create a widget in one db using #{ENV['ORM'].downcase}" end When /^I create a widget in another db$/ do step "I create a widget in another db using #{ENV['ORM'].downcase}" end Then /^I should see 1 widget in one db$/ do step "I should see 1 widget in one db using #{ENV['ORM'].downcase}" end Then /^I should see 1 widget in another db$/ do step "I should see 1 widget in another db using #{ENV['ORM'].downcase}" end Then /^I should see 0 widget in another db$/ do step "I should see 0 widget in another db using #{ENV['ORM'].downcase}" end Then /^I should see 0 widget in one db$/ do step "I should see 0 widget in one db using #{ENV['ORM'].downcase}" end database_cleaner-1.7.0/examples/features/support/ 0000775 0000000 0000000 00000000000 13266175307 0022136 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/features/support/env.rb 0000664 0000000 0000000 00000005062 13266175307 0023256 0 ustar 00root root 0000000 0000000 #Hilarious as it seems, this is necessary so bundle exec cucumber works for mongoid cukeage (I'm assuming mongomapper is automatically present because its a git repo) Object.send(:remove_const, 'MongoMapper') if defined?(::MongoMapper) require 'rubygems' require 'bundler' Bundler.setup require 'rspec/expectations' #require 'ruby-debug' DB_DIR = "#{File.dirname(__FILE__)}/../../db" orm = ENV['ORM'] another_orm = ENV['ANOTHER_ORM'] strategy = ENV['STRATEGY'] multiple_db = ENV['MULTIPLE_DBS'] config = YAML::load(File.open("#{File.dirname(__FILE__)}/../../config/redis.yml")) ENV['REDIS_URL'] = config['test']['url'] ENV['REDIS_URL_ONE'] = config['one']['url'] ENV['REDIS_URL_TWO'] = config['two']['url'] if orm && strategy $:.unshift(File.dirname(__FILE__) + '/../../../lib') require 'database_cleaner' require 'database_cleaner/cucumber' require "#{File.dirname(__FILE__)}/../../lib/#{orm.downcase}_models" if another_orm require "#{File.dirname(__FILE__)}/../../lib/#{another_orm.downcase}_models" end if multiple_db DatabaseCleaner.app_root = "#{File.dirname(__FILE__)}/../.." orm_sym = orm.gsub(/(.)([A-Z]+)/,'\1_\2').downcase.to_sym case orm_sym when :mongo_mapper DatabaseCleaner[ orm_sym, {:connection => 'database_cleaner_test_one'} ].strategy = strategy.to_sym DatabaseCleaner[ orm_sym, {:connection => 'database_cleaner_test_two'} ].strategy = strategy.to_sym when :redis, :ohm DatabaseCleaner[ orm_sym, {:connection => ENV['REDIS_URL_ONE']} ].strategy = strategy.to_sym DatabaseCleaner[ orm_sym, {:connection => ENV['REDIS_URL_TWO']} ].strategy = strategy.to_sym when :active_record DatabaseCleaner[:active_record, {:model => ActiveRecordWidgetUsingDatabaseOne} ].strategy = strategy.to_sym DatabaseCleaner[:active_record, {:model => ActiveRecordWidgetUsingDatabaseTwo} ].strategy = strategy.to_sym else DatabaseCleaner[ orm_sym, {:connection => :one} ].strategy = strategy.to_sym DatabaseCleaner[ orm_sym, {:connection => :two} ].strategy = strategy.to_sym end elsif another_orm DatabaseCleaner[ orm.gsub(/(.)([A-Z]+)/,'\1_\2').downcase.to_sym ].strategy = strategy.to_sym DatabaseCleaner[ another_orm.gsub(/(.)([A-Z]+)/,'\1_\2').downcase.to_sym ].strategy = strategy.to_sym else DatabaseCleaner.strategy = strategy.to_sym unless strategy == "default" end else raise "Run 'ORM=ActiveRecord|DataMapper|MongoMapper|CouchPotato|Ohm|Redis [ANOTHER_ORM=...] [MULTIPLE_DBS=true] STRATEGY=transaction|truncation|default cucumber examples/features'" end database_cleaner-1.7.0/examples/lib/ 0000775 0000000 0000000 00000000000 13266175307 0017352 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/examples/lib/activerecord_models.rb 0000664 0000000 0000000 00000003044 13266175307 0023715 0 ustar 00root root 0000000 0000000 require 'active_record' databases_config = { "one" => {"adapter" => "#{"jdbc" if defined?(JRUBY_VERSION)}sqlite3", "database" => "#{DB_DIR}/activerecord_one.db"}, "two" => {"adapter" => "#{"jdbc" if defined?(JRUBY_VERSION)}sqlite3", "database" => "#{DB_DIR}/activerecord_two.db"} } File.open("#{File.dirname(__FILE__)}/../config/database.yml", 'w') do |file| file.write(YAML.dump(databases_config)) end ["two","one"].each do |db| ActiveRecord::Base.establish_connection(databases_config[db]) ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS "active_record_widgets"') ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS "active_record_widget_using_database_ones"') ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS "active_record_widget_using_database_twos"') ActiveRecord::Schema.define(:version => 1) do create_table :active_record_widgets do |t| t.string :name end create_table :active_record_widget_using_database_ones do |t| t.string :name end create_table :active_record_widget_using_database_twos do |t| t.string :name end end end class ActiveRecordWidget < ActiveRecord::Base end class ActiveRecordWidgetUsingDatabaseOne < ActiveRecord::Base establish_connection(:adapter => "#{"jdbc" if defined?(JRUBY_VERSION)}sqlite3", :database => "#{DB_DIR}/activerecord_one.db") end class ActiveRecordWidgetUsingDatabaseTwo < ActiveRecord::Base establish_connection(:adapter => "#{"jdbc" if defined?(JRUBY_VERSION)}sqlite3", :database => "#{DB_DIR}/activerecord_two.db") end database_cleaner-1.7.0/examples/lib/couchpotato_models.rb 0000664 0000000 0000000 00000002243 13266175307 0023573 0 ustar 00root root 0000000 0000000 require 'couch_potato' require 'json/pure' unless defined? ::JSON ::CouchPotato::Config.database_name = 'couch_potato_test' class CouchPotatoWidget include CouchPotato::Persistence property :name view :by_name, :key => :name # mimic the AR interface used in example_steps def self.create!(attrs = {}) CouchPotato.database.save(self.new) end def self.count CouchPotato.database.view(self.by_name).size end end class CouchPotatoWidgetUsingDatabaseOne include CouchPotato::Persistence database_name = 'couch_potato_test_one' property :name view :by_name, :key => :name # mimic the AR interface used in example_steps def self.create!(attrs = {}) CouchPotato.database.save(self.new) end def self.count CouchPotato.database.view(self.by_name).size end end class CouchPotatoWidgetUsingDatabaseTwo include CouchPotato::Persistence database_name = 'couch_potato_test_two' property :name view :by_name, :key => :name # mimic the AR interface used in example_steps def self.create!(attrs = {}) CouchPotato.database.save(self.new) end def self.count CouchPotato.database.view(self.by_name).size end end database_cleaner-1.7.0/examples/lib/datamapper_models.rb 0000664 0000000 0000000 00000002114 13266175307 0023356 0 ustar 00root root 0000000 0000000 require "dm-core" require "dm-transactions" #Datamapper 1.0 requires you to require dm-migrations to automigrate require "dm-migrations" # only to please activerecord API used in database_cleaner/examples/features/step_definitions # yes, i know that's lazy ... require "dm-validations" require "dm-aggregates" DataMapper.setup(:default, "sqlite3:#{DB_DIR}/datamapper_default.db") DataMapper.setup(:one, "sqlite3:#{DB_DIR}/datamapper_one.db") DataMapper.setup(:two, "sqlite3:#{DB_DIR}/datamapper_two.db") class DataMapperWidget include DataMapper::Resource property :id, Serial property :name, String end class DataMapperWidgetUsingDatabaseOne include DataMapper::Resource def self.default_repository_name :one end property :id, Serial property :name, String end class DataMapperWidgetUsingDatabaseTwo include DataMapper::Resource def self.default_repository_name :two end property :id, Serial property :name, String end DataMapperWidget.auto_migrate! DataMapperWidgetUsingDatabaseOne.auto_migrate! DataMapperWidgetUsingDatabaseTwo.auto_migrate! database_cleaner-1.7.0/examples/lib/mongoid_models.rb 0000664 0000000 0000000 00000001452 13266175307 0022700 0 ustar 00root root 0000000 0000000 require 'mongoid' Mongoid.configure do |config| config.master = Mongo::Connection.new.db('database_cleaner_test') end class MongoidWidget include Mongoid::Document field :id, :type => Integer field :name class << self #mongoid doesn't seem to provide this... def create!(*args) new(*args).save! end end end class MongoidWidgetUsingDatabaseOne include Mongoid::Document field :id, :type => Integer field :name class << self #mongoid doesn't seem to provide this... def create!(*args) new(*args).save! end end end class MongoidWidgetUsingDatabaseTwo include Mongoid::Document field :id, :type => Integer field :name class << self #mongoid doesn't seem to provide this... def create!(*args) new(*args).save! end end end database_cleaner-1.7.0/examples/lib/mongomapper_models.rb 0000664 0000000 0000000 00000002031 13266175307 0023562 0 ustar 00root root 0000000 0000000 require 'mongo_mapper' ::MongoMapper.connection = Mongo::Connection.new('127.0.0.1') ::MongoMapper.database = 'database_cleaner_test' class MongoMapperWidget include MongoMapper::Document key :id, Integer key :name, String class << self #mongomapper doesn't seem to provide this... def create!(*args) new(*args).save! end end end class MongoMapperWidgetUsingDatabaseOne include MongoMapper::Document connection = Mongo::Connection.new('127.0.0.1') set_database_name = 'database_cleaner_test_one' key :id, Integer key :name, String class << self #mongomapper doesn't seem to provide this... def create!(*args) new(*args).save! end end end class MongoMapperWidgetUsingDatabaseTwo include MongoMapper::Document connection = Mongo::Connection.new('127.0.0.1') set_database_name = 'database_cleaner_test_two' key :id, Integer key :name, String class << self #mongomapper doesn't seem to provide this... def create!(*args) new(*args).save! end end end database_cleaner-1.7.0/examples/lib/neo4j_models.rb 0000664 0000000 0000000 00000000452 13266175307 0022262 0 ustar 00root root 0000000 0000000 require 'neo4j-core' class Neo4jWidget < Neo4j::Node def self.create!(*args) create(*args) end def self.count Neo4j::Session.query.match('n').pluck('COUNT(n)').first end end class Neo4jWidgetUsingDatabaseOne < Neo4jWidget end class Neo4jWidgetUsingDatabaseTwo < Neo4jWidget end database_cleaner-1.7.0/examples/lib/ohm_models.rb 0000664 0000000 0000000 00000001340 13266175307 0022023 0 ustar 00root root 0000000 0000000 require 'ohm' Ohm.connect :url => ENV['REDIS_URL'] class OhmWidget < Ohm::Model attribute :name def self.create!(attrs = {}) new({:name => 'some widget'}.merge(attrs)).save end def self.count all.count end end class OhmWidgetUsingDatabaseOne < Ohm::Model connect :url => ENV['REDIS_URL_ONE'] attribute :name def self.create!(attrs = {}) new({:name => 'a widget using database one'}.merge(attrs)).save end def self.count all.count end end class OhmWidgetUsingDatabaseTwo < Ohm::Model connect :url => ENV['REDIS_URL_TWO'] attribute :name def self.create!(attrs = {}) new({:name => 'a widget using database two'}.merge(attrs)).save end def self.count all.count end end database_cleaner-1.7.0/examples/lib/redis_models.rb 0000664 0000000 0000000 00000002266 13266175307 0022356 0 ustar 00root root 0000000 0000000 require 'redis' class RedisWidget def self.redis threaded ||= Redis.new end def self.redis=(connection) threaded = connection end def self.threaded Thread.current[self.class.to_s] ||= {} end def initialize(options = {}) options = options.dup @name = options[:name] end def connection self.class.redis end def save unless connection.get(self.class.to_s + ':id') @id = 0 connection.set(self.class.to_s + ':id', @id) end @id = connection.incr(self.class.to_s + ':id') connection.set(self.class.to_s + ':%d:name' % @id, @name) end def self.count self.redis.keys(self.to_s + '*name').size end def self.create! new(:name => 'some widget').save end end class RedisWidgetUsingDatabaseOne < RedisWidget def self.redis threaded[self.class.to_s] ||= Redis.new :url => ENV['REDIS_URL_ONE'] end def self.create! new(:name => 'a widget using database one').save end end class RedisWidgetUsingDatabaseTwo < RedisWidget def self.redis threaded[self.class.to_s] ||= Redis.new :url => ENV['REDIS_URL_TWO'] end def self.create! new(:name => 'a widget using database two').save end end database_cleaner-1.7.0/examples/lib/sequel_models.rb 0000664 0000000 0000000 00000000236 13266175307 0022541 0 ustar 00root root 0000000 0000000 require 'sequel' db = Sequel.sqlite # memory database db.run 'DROP TABLE IF EXISTS "sequel_widgets"' db.create_table :sequel_widgets do String :name end database_cleaner-1.7.0/features/ 0000775 0000000 0000000 00000000000 13266175307 0016604 5 ustar 00root root 0000000 0000000 database_cleaner-1.7.0/features/cleaning.feature 0000664 0000000 0000000 00000001646 13266175307 0021750 0 ustar 00root root 0000000 0000000 Feature: database cleaning In order to ease example and feature writing As a developer I want to have my database in a clean state Scenario Outline: ruby app Given I am using