database_cleaner 0.5.0 → 0.6.0.rc.1

data/examples/features/step_definitions/mongomapper_steps.rb

@@ -0,0 +1,31 @@
+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

data/examples/features/step_definitions/translation_steps.rb

@@ -0,0 +1,55 @@
+When /^I create a widget$/ do
+  When "I create a widget using #{ENV['ORM'].downcase}"
+end
+
+Then /^I should see 1 widget$/ do
+  Then "I should see 1 widget using #{ENV['ORM'].downcase}"
+end
+
+When /^I create a widget in one orm$/ do
+  When "I create a widget using #{ENV['ORM'].downcase}"
+end
+
+When /^I create a widget in another orm$/ do
+  When "I create a widget using #{ENV['ANOTHER_ORM'].downcase}"
+end
+
+Then /^I should see 1 widget in one orm$/ do
+  When "I should see 1 widget using #{ENV['ORM'].downcase}"
+end
+
+Then /^I should see 1 widget in another orm$/ do
+  When "I should see 1 widget using #{ENV['ANOTHER_ORM'].downcase}"
+end
+
+Then /^I should see 0 widget in another orm$/ do
+  When "I should see 0 widget using #{ENV['ANOTHER_ORM'].downcase}"
+end
+
+Then /^I should see 0 widget in one orm$/ do
+  When "I should see 0 widget using #{ENV['ORM'].downcase}"
+end
+
+When /^I create a widget in one db$/ do
+  When "I create a widget in one db using #{ENV['ORM'].downcase}"
+end
+
+When /^I create a widget in another db$/ do
+  When "I create a widget in another db using #{ENV['ORM'].downcase}"
+end
+
+Then /^I should see 1 widget in one db$/ do
+  When "I should see 1 widget in one db using #{ENV['ORM'].downcase}"
+end
+
+Then /^I should see 1 widget in another db$/ do
+  When "I should see 1 widget in another db using #{ENV['ORM'].downcase}"
+end
+
+Then /^I should see 0 widget in another db$/ do
+  When "I should see 0 widget in another db using #{ENV['ORM'].downcase}"
+end
+
+Then /^I should see 0 widget in one db$/ do
+  When "I should see 0 widget in one db using #{ENV['ORM'].downcase}"
+end

data/examples/features/support/env.rb

@@ -1,23 +1,62 @@
+#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 'spec/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']
 
-orm      = ENV['ORM']
-strategy = ENV['STRATEGY']
 
 if orm && strategy
+  $:.unshift(File.dirname(__FILE__) + '/../../../lib')
+  require 'database_cleaner'
+  require 'database_cleaner/cucumber'
 
   begin
-    require "#{File.dirname(__FILE__)}/../../lib/#{orm}_models"
-  rescue LoadError
+    require "#{File.dirname(__FILE__)}/../../lib/#{orm.downcase}_models"
+  rescue LoadError => e
     raise "You don't have the #{orm} ORM installed"
   end
 
-  $:.unshift(File.dirname(__FILE__) + '/../../../lib')
-  require 'database_cleaner'
-  require 'database_cleaner/cucumber'
+  if another_orm
+     begin
+      require "#{File.dirname(__FILE__)}/../../lib/#{another_orm.downcase}_models"
+    rescue LoadError => e
+      raise "You don't have the #{another_orm} ORM installed"
+    end
+  end
+
+
+
+
+  if multiple_db 
+    DatabaseCleaner.app_root = "#{File.dirname(__FILE__)}/../.."
+    orm_sym = orm.gsub(/(.)([A-Z]+)/,'\1_\2').downcase.to_sym
+
+    if orm_sym == :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
+    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
+  end
 
-  DatabaseCleaner.strategy = strategy.to_sym
-  
 else
-  raise "Run 'ORM=activerecord|datamapper|mongomapper|couchpotato STRATEGY=transaction|truncation cucumber examples/features'"
+  raise "Run 'ORM=ActiveRecord|DataMapper|MongoMapper|CouchPotato [ANOTHER_ORM=...] [MULTIPLE_DBS=true] STRATEGY=transaction|truncation cucumber examples/features'"
 end

data/examples/lib/activerecord_models.rb

@@ -1,12 +1,41 @@
 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"}
+}
 
-ActiveRecord::Base.establish_connection(:adapter => "#{"jdbc" if defined?(JRUBY_VERSION)}sqlite3", :database => ":memory:")
+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
 
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :widgets do |t|
-    t.string :name
+    create_table :active_record_widget_using_database_twos do |t|
+      t.string :name
+    end
   end
 end
 
-class Widget < ActiveRecord::Base
+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

data/examples/lib/couchpotato_models.rb

@@ -1,21 +1,61 @@
 require 'couch_potato'
-
+require 'json/pure' unless defined? ::JSON
 ::CouchPotato::Config.database_name = 'couch_potato_test'
 
-class Widget
+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(::Widget.by_name).size
+    CouchPotato.database.view(self.by_name).size
   end
 end

data/examples/lib/datamapper_models.rb

@@ -1,16 +1,50 @@
 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::memory:")
+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 Widget
+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
 
-Widget.auto_migrate!
+DataMapperWidget.auto_migrate!
+DataMapperWidgetUsingDatabaseOne.auto_migrate!
+DataMapperWidgetUsingDatabaseTwo.auto_migrate!

data/examples/lib/mongoid_models.rb

@@ -0,0 +1,49 @@
+require 'mongoid'
+
+Mongoid.configure do |config|
+  name = 'database_cleaner_test'
+  config.master = Mongo::Connection.new.db(name)
+end
+
+
+#::MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
+#::MongoMapper.database = 'database_cleaner_test'
+
+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

data/examples/lib/mongomapper_models.rb

@@ -1,9 +1,9 @@
-require 'mongomapper'
+require 'mongo_mapper'
 
 ::MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
 ::MongoMapper.database = 'database_cleaner_test'
 
-class Widget
+class MongoMapperWidget
   include MongoMapper::Document
   key :id, Integer
   key :name, String
@@ -15,3 +15,37 @@ class Widget
     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

data/features/cleaning.feature

@@ -17,4 +17,5 @@ Feature: database cleaning
     | DataMapper   | transaction   |
     | DataMapper   | truncation    |
     | MongoMapper  | truncation    |
+    | Mongoid      | truncation    |
     | CouchPotato  | truncation    |

data/features/cleaning_multiple_dbs.feature

@@ -0,0 +1,20 @@
+Feature: multiple database cleaning
+  In order to ease example and feature writing
+  As a developer
+  I want to have my databases in a clean state
+
+  Scenario Outline: ruby app
+    Given I am using <ORM>
+    And the <Strategy> cleaning strategy
+
+    When I run my scenarios that rely on clean databases
+    Then I should see all green
+
+  Examples:
+  | ORM          | Strategy      |
+  | ActiveRecord | truncation    |
+  | DataMapper   | truncation    |
+  | MongoMapper  | truncation    |
+  | DataMapper   | transaction   |
+# Not working...
+#| ActiveRecord | transaction   |

data/features/cleaning_multiple_orms.feature

@@ -0,0 +1,29 @@
+Feature: database cleaning using multiple ORMs
+  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 <ORM1> and <ORM2>
+
+    When I run my scenarios that rely on clean databases using multiple orms
+    Then I should see all green
+
+  Examples:
+    | ORM1         | ORM2         |
+    | ActiveRecord | DataMapper   |
+    | ActiveRecord | MongoMapper  |
+    | ActiveRecord | Mongoid      |
+    | ActiveRecord | CouchPotato  |
+    | DataMapper   | ActiveRecord |
+    | DataMapper   | MongoMapper  |
+    | DataMapper   | Mongoid      |
+    | DataMapper   | CouchPotato  |
+    | MongoMapper  | ActiveRecord |
+    | MongoMapper  | DataMapper   |
+    | MongoMapper  | Mongoid      |
+    | MongoMapper  | CouchPotato  |
+    | CouchPotato  | ActiveRecord |
+    | CouchPotato  | DataMapper   |
+    | CouchPotato  | MongoMapper  |
+    | CouchPotato  | Mongoid      |

data/features/step_definitions/database_cleaner_steps.rb

@@ -1,25 +1,32 @@
-Given /^I am using (ActiveRecord|DataMapper|MongoMapper|CouchPotato)$/ do |orm|
-  @orm = orm
+
+Given /^I am using (ActiveRecord|DataMapper|MongoMapper|Mongoid|CouchPotato)$/ do |orm|
+  @feature_runner = FeatureRunner.new
+  @feature_runner.orm = orm
+end
+
+Given /^I am using (ActiveRecord|DataMapper|MongoMapper|CouchPotato|Mongoid) and (ActiveRecord|DataMapper|MongoMapper|CouchPotato|Mongoid)$/ do |orm1,orm2|
+  @feature_runner = FeatureRunner.new
+  @feature_runner.orm         = orm1
+  @feature_runner.another_orm = orm2
 end
 
 Given /^the (.+) cleaning strategy$/ do |strategy|
-  @strategy = strategy
+  @feature_runner.strategy = strategy
 end
 
 When "I run my scenarios that rely on a clean database" do
-  full_dir ||= File.expand_path(File.dirname(__FILE__) + "/../../examples/")
-  Dir.chdir(full_dir) do
-    ENV['ORM'] = @orm.downcase
-    ENV['STRATEGY'] = @strategy
-    @out = `#{"jruby -S " if defined?(JRUBY_VERSION)}cucumber features`
-    @status = $?.exitstatus
-  end
+  @feature_runner.go 'example'
 end
 
-Then "I should see all green" do
-  unless @status == 0
-    raise "Expected to see all green but we saw FAIL! Output:\n#{@out}"
-  end
+When "I run my scenarios that rely on clean databases" do
+  @feature_runner.multiple_databases = true
+  @feature_runner.go 'example_multiple_db'
 end
 
+When "I run my scenarios that rely on clean databases using multiple orms" do
+  @feature_runner.go 'example_multiple_orm'
+end
 
+Then "I should see all green" do
+  fail "Feature failed with :#{@feature_runner.output}" unless @feature_runner.exit_status == 0
+end

data/features/support/feature_runner.rb

@@ -0,0 +1,39 @@
+class FeatureRunner
+  attr_accessor :orm
+  attr_accessor :another_orm
+  attr_accessor :multiple_databases
+  attr_accessor :strategy
+  attr_accessor :exit_status
+  attr_accessor :output
+
+  def strategy
+    @strategy || 'truncation'
+  end
+
+  def go(feature)
+    full_dir ||= File.expand_path(File.dirname(__FILE__) + "/../../examples/")
+    Dir.chdir(full_dir) do
+                              
+      
+      ENV['ORM']          = orm
+      ENV['STRATEGY']     = strategy
+      
+      if another_orm
+       ENV['ANOTHER_ORM']  = another_orm
+      else
+        ENV['ANOTHER_ORM'] = nil
+      end
+      
+      if multiple_databases
+        ENV['MULTIPLE_DBS'] = "true"
+      else
+        ENV['MULTIPLE_DBS'] = nil 
+      end
+
+      self.output = `#{"jruby -S " if defined?(JRUBY_VERSION)}cucumber features/#{feature}.feature`
+
+      self.exit_status = $?.exitstatus
+    end
+  end
+
+end

data/lib/database_cleaner/active_record/base.rb

@@ -0,0 +1,46 @@
+require 'database_cleaner/generic/base'
+require 'active_record'
+
+module DatabaseCleaner
+  module ActiveRecord
+
+    def self.available_strategies
+      %w[truncation transaction]
+    end
+
+    def self.config_file_location
+      "#{DatabaseCleaner.app_root}/config/database.yml"
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      attr_accessor :connection_hash
+
+      def db=(desired_db)
+        @db = desired_db
+        load_config
+      end
+
+      def db
+        @db || super
+      end
+
+      def load_config
+        connection_details = YAML::load(ERB.new(IO.read(ActiveRecord.config_file_location)).result)
+        self.connection_hash = connection_details[self.db.to_s]
+      end
+
+      def create_connection_klass
+        Class.new(::ActiveRecord::Base)
+      end
+
+      def connection_klass
+        return ::ActiveRecord::Base if connection_hash.nil?
+        klass = create_connection_klass
+        klass.send :establish_connection, connection_hash
+        klass
+      end
+    end
+  end
+end

data/lib/database_cleaner/active_record/transaction.rb

@@ -1,26 +1,26 @@
+require 'database_cleaner/active_record/base'
 module DatabaseCleaner::ActiveRecord
   class Transaction
+    include ::DatabaseCleaner::ActiveRecord::Base
 
     def start
-      if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
-        ActiveRecord::Base.connection.increment_open_transactions
+      if connection_klass.connection.respond_to?(:increment_open_transactions)
+        connection_klass.connection.increment_open_transactions
       else
-        ActiveRecord::Base.__send__(:increment_open_transactions)
+        connection_klass.__send__(:increment_open_transactions)
       end
-
-      ActiveRecord::Base.connection.begin_db_transaction
+      connection_klass.connection.begin_db_transaction
     end
 
 
     def clean
-      ActiveRecord::Base.connection.rollback_db_transaction
+      connection_klass.connection.rollback_db_transaction
 
-      if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
-        ActiveRecord::Base.connection.decrement_open_transactions
+      if connection_klass.connection.respond_to?(:decrement_open_transactions)
+        connection_klass.connection.decrement_open_transactions
       else
-        ActiveRecord::Base.__send__(:decrement_open_transactions)
+        connection_klass.__send__(:decrement_open_transactions)
       end
     end
   end
-
 end