database_cleaner 0.5.2 → 0.6.0.rc.1

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

@@ -9,15 +9,41 @@ end
 #::MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
 #::MongoMapper.database = 'database_cleaner_test'
 
-class Widget
+class MongoidWidget
   include Mongoid::Document
   field :id, :type => Integer
   field :name
 
   class << self
-    #mongomapper doesn't seem to provide this...
+    #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

@@ -3,7 +3,7 @@ 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_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|Mongoid|CouchPotato)$/ do |orm|
-  @orm = 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

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,6 +1,7 @@
 require 'active_record/base'
 require 'active_record/connection_adapters/abstract_adapter'
-require "database_cleaner/truncation_base"
+require "database_cleaner/generic/truncation"
+require 'database_cleaner/active_record/base'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -17,6 +18,12 @@ module ActiveRecord
       end
     end
 
+    class Mysql2Adapter < AbstractAdapter
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+    end
+
     class SQLite3Adapter < SQLiteAdapter
       def truncate_table(table_name)
         execute("DELETE FROM #{quote_table_name(table_name)};")
@@ -36,9 +43,9 @@ module ActiveRecord
     class PostgreSQLAdapter < AbstractAdapter
 
       def self.db_version
-        @db_version ||= ActiveRecord::Base.connection.select_values(
-          "SELECT CHARACTER_VALUE 
-            FROM INFORMATION_SCHEMA.SQL_IMPLEMENTATION_INFO 
+        @db_version ||= connection.select_values(
+          "SELECT CHARACTER_VALUE
+            FROM INFORMATION_SCHEMA.SQL_IMPLEMENTATION_INFO
             WHERE IMPLEMENTATION_INFO_NAME = 'DBMS VERSION' ").to_s
       end
 
@@ -69,7 +76,9 @@ end
 
 
 module DatabaseCleaner::ActiveRecord
-  class Truncation < ::DatabaseCleaner::TruncationBase
+  class Truncation
+    include ::DatabaseCleaner::ActiveRecord::Base
+    include ::DatabaseCleaner::Generic::Truncation
 
     def clean
       connection.disable_referential_integrity do
@@ -82,11 +91,12 @@ module DatabaseCleaner::ActiveRecord
     private
 
     def tables_to_truncate
-      (@only || connection.tables) - @tables_to_exclude
+       (@only || connection.tables) - @tables_to_exclude
     end
 
     def connection
-      ::ActiveRecord::Base.connection
+       #::ActiveRecord::Base.connection
+       connection_klass.connection
     end
 
     # overwritten

data/lib/database_cleaner/base.rb

@@ -0,0 +1,129 @@
+module DatabaseCleaner
+  class Base
+
+    def initialize(desired_orm = nil,opts = {})
+      if desired_orm == :autodetect || desired_orm.nil?
+        autodetect
+      else
+        self.orm = desired_orm
+      end
+      self.db = opts[:connection] if opts.has_key? :connection
+    end
+
+    def db=(desired_db)
+       self.strategy_db = desired_db
+       @db = desired_db
+    end
+    
+    def strategy_db=(desired_db)
+      if strategy.respond_to? :db=
+        strategy.db = desired_db
+      elsif desired_db!= :default
+        raise ArgumentError, "You must provide a strategy object that supports non default databases when you specify a database"
+      end
+    rescue NoStrategySetError
+      #handle NoStrategySetError by doing nothing at all
+      desired_db
+    end
+
+    def db
+      @db || :default
+    end
+
+    def create_strategy(*args)
+      strategy, *strategy_args = args
+      orm_strategy(strategy).new(*strategy_args)
+    end
+
+    def clean_with(*args)
+      strategy = create_strategy(*args)
+      strategy.clean
+      strategy
+    end
+
+    alias clean_with! clean_with
+
+    def strategy=(args)
+      strategy, *strategy_args = args
+       if strategy.is_a?(Symbol)
+          @strategy = create_strategy(*args)
+       elsif strategy_args.empty?
+         @strategy = strategy
+       else
+         raise ArgumentError, "You must provide a strategy object, or a symbol for a known strategy along with initialization params."
+       end
+
+       self.strategy_db = self.db
+       
+       @strategy
+    end
+
+    def strategy
+      return @strategy if @strategy
+      raise NoStrategySetError, "Please set a strategy with DatabaseCleaner.strategy=."
+    end
+
+    def orm=(desired_orm)
+      @orm = desired_orm
+    end
+
+    def orm
+      @orm || autodetect
+    end
+
+    def start
+      strategy.start
+    end
+
+    def clean
+      strategy.clean
+    end
+
+    alias clean! clean
+
+    def auto_detected?
+      return true unless @autodetected.nil?
+    end
+
+    #TODO make strategies directly comparable
+    def ==(other)
+      self.orm == other.orm && self.db == other.db && self.strategy.class == other.strategy.class
+    end
+
+    private
+
+    def orm_module
+      ::DatabaseCleaner.orm_module(orm)
+    end
+
+    def orm_strategy(strategy)
+      require "database_cleaner/#{orm.to_s}/#{strategy.to_s}"
+      orm_module.const_get(strategy.to_s.capitalize)
+    rescue LoadError => e
+      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
+      @orm ||= begin
+        @autodetected = true
+        if defined? ::ActiveRecord
+          :active_record
+        elsif defined? ::DataMapper
+          :data_mapper
+        elsif defined? ::MongoMapper
+          :mongo_mapper
+        elsif defined? ::Mongoid
+          :mongoid
+        elsif defined? ::CouchPotato
+          :couch_potato
+        else
+          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, MongoMapper, Mongoid, or CouchPotato loaded?"
+        end
+      end
+    end
+  end
+end