database_cleaner 0.5.0 → 0.6.0.rc.1

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,21 +1,36 @@
-require "database_cleaner/truncation_base"
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require "database_cleaner/generic/truncation"
+require 'database_cleaner/active_record/base'
 
 module ActiveRecord
   module ConnectionAdapters
 
-    class MysqlAdapter
+    class AbstractAdapter
+    end
+
+    class SQLiteAdapter < AbstractAdapter
+    end
+
+    class MysqlAdapter < AbstractAdapter
       def truncate_table(table_name)
         execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
       end
     end
 
-    class SQLite3Adapter
+    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)};")
       end
     end
 
-    class JdbcAdapter
+    class JdbcAdapter < AbstractAdapter
       def truncate_table(table_name)
         begin
           execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
@@ -25,19 +40,32 @@ module ActiveRecord
       end
     end
 
-    class PostgreSQLAdapter
+    class PostgreSQLAdapter < AbstractAdapter
+
+      def self.db_version
+        @db_version ||= connection.select_values(
+          "SELECT CHARACTER_VALUE
+            FROM INFORMATION_SCHEMA.SQL_IMPLEMENTATION_INFO
+            WHERE IMPLEMENTATION_INFO_NAME = 'DBMS VERSION' ").to_s
+      end
+
+      def self.cascade
+        @cascade ||= db_version >=  "08.02" ? "CASCADE" : ""
+      end
+
       def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)} CASCADE;")
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)} #{self.class.cascade};")
       end
+
     end
 
-    class SQLServerAdapter
+    class SQLServerAdapter < AbstractAdapter
       def truncate_table(table_name)
         execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
       end
     end
 
-    class OracleEnhancedAdapter
+    class OracleEnhancedAdapter < AbstractAdapter
       def truncate_table(table_name)
         execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
       end
@@ -48,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
@@ -61,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

data/lib/database_cleaner/configuration.rb

@@ -1,114 +1,77 @@
+require 'database_cleaner/base'
+
 module DatabaseCleaner
 
   class NoStrategySetError < StandardError;   end
   class NoORMDetected < StandardError;   end
   class UnknownStrategySpecified < ArgumentError;   end
 
-  module ActiveRecord
-    def self.available_strategies
-      %w[truncation transaction]
+  class << self
+    def [](orm,opts = {})
+      raise NoORMDetected if orm.nil?
+      @connections ||= []
+      cleaner = DatabaseCleaner::Base.new(orm,opts)
+      connections.push cleaner
+      cleaner
     end
-  end
 
-  module DataMapper
-    def self.available_strategies
-      %w[truncation transaction]
-    end
-  end
-  
-  module MongoMapper
-    def self.available_strategies
-      %w[truncation]
+    def app_root=(desired_root)
+      @app_root = desired_root
     end
-  end
 
-  module CouchPotato
-    def self.available_strategies
-      %w[truncation]
+    def app_root
+      @app_root || Dir.pwd
     end
-  end
 
-  class << self
-
-    def create_strategy(*args)
-      strategy, *strategy_args = args
-      orm_strategy(strategy).new(*strategy_args)
+    def connections
+      @connections ||= [::DatabaseCleaner::Base.new]
     end
 
-    def clean_with(*args)
-      strategy = create_strategy(*args)
-      strategy.clean
-      strategy
+    def strategy=(stratagem)
+      self.connections.each { |connect| connect.strategy = stratagem }
+      remove_duplicates
     end
 
-    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 know strategy along with initialization params."
-       end
-    end
-
-    def orm=(orm_string)
-      @orm = orm_string
+    def orm=(orm)
+      self.connections.each { |connect| connect.orm = orm }
+      remove_duplicates
     end
 
     def start
-      strategy.start
+      self.connections.each { |connection| connection.start }
     end
 
     def clean
-      strategy.clean
+      self.connections.each { |connection| connection.clean }
     end
 
-    private
-
-    def strategy
-      return @strategy if @strategy
-      raise NoStrategySetError, "Please set a strategy with DatabaseCleaner.strategy=."
+    def clean_with(stratagem)
+      self.connections.each { |connection| connection.clean_with stratagem }
     end
 
-    def orm_strategy(strategy)
-      require "database_cleaner/#{orm}/#{strategy}"
-      orm_module.const_get(strategy.to_s.capitalize)
-    rescue LoadError => e
-      raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{orm_module.available_strategies.join(', ')}"
-    end
-
-
-    def orm
-      @orm ||=begin
-        if defined? ::ActiveRecord
-          'active_record'
-        elsif defined? ::DataMapper
-          'data_mapper'
-        elsif defined? ::MongoMapper
-          'mongo_mapper'
-        elsif defined? ::CouchPotato
-          'couch_potato'
-        else
-          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, MongoMapper or CouchPotato loaded?"
-        end
+    def remove_duplicates
+      temp = []
+      self.connections.each do |connect|
+        temp.push connect unless temp.include? connect
       end
+      @connections = temp
     end
-
-
-    def orm_module
-      case orm
-      when 'active_record'
-        DatabaseCleaner::ActiveRecord
-      when 'data_mapper'
-        DatabaseCleaner::DataMapper
-      when 'mongo_mapper'
-        DatabaseCleaner::MongoMapper
-      when 'couch_potato'
-        DatabaseCleaner::CouchPotato
+    
+    def orm_module(symbol)
+      case symbol
+        when :active_record
+          DatabaseCleaner::ActiveRecord
+        when :data_mapper
+          DatabaseCleaner::DataMapper
+        when :mongo
+          DatabaseCleaner::Mongo
+        when :mongoid
+          DatabaseCleaner::Mongoid
+        when :mongo_mapper
+          DatabaseCleaner::MongoMapper
+        when :couch_potato
+          DatabaseCleaner::CouchPotato
       end
     end
-
   end
-
 end

data/lib/database_cleaner/couch_potato/base.rb

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

data/lib/database_cleaner/couch_potato/truncation.rb

@@ -1,8 +1,10 @@
-require 'database_cleaner/truncation_base'
+require 'database_cleaner/generic/truncation'
 
 module DatabaseCleaner
   module CouchPotato
-    class Truncation < DatabaseCleaner::TruncationBase
+    class Truncation
+      include ::DatabaseCleaner::Generic::Truncation
+
       def initialize(options = {})
         if options.has_key?(:only) || options.has_key?(:except)
           raise ArgumentError, "The :only and :except options are not available for use with CouchPotato/CouchDB."

data/lib/database_cleaner/cucumber.rb

@@ -1,4 +1,3 @@
-
 Before do
   DatabaseCleaner.start
 end

data/lib/database_cleaner/data_mapper/base.rb

@@ -0,0 +1,21 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module DataMapper
+    def self.available_strategies
+      %w[truncation transaction]
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      def db=(desired_db)
+        @db = desired_db
+      end
+
+      def db
+        @db || :default
+      end
+
+    end
+  end
+end

data/lib/database_cleaner/data_mapper/transaction.rb

@@ -1,16 +1,21 @@
+require 'database_cleaner/data_mapper/base'
+
 module DatabaseCleaner::DataMapper
   class Transaction
-
-    def start(repo = :default)
-      DataMapper.repository(repo) do |r|
+    include ::DatabaseCleaner::DataMapper::Base
+    #TODO Figure out repositories, may have to refactor connection_klass to something more sensible
+    def start(repository = nil)
+      repository = self.db if repository.nil?
+      ::DataMapper.repository(repository) do |r|
         transaction = DataMapper::Transaction.new(r)
         transaction.begin
         r.adapter.push_transaction(transaction)
       end
     end
 
-    def clean(repo = :default)
-      DataMapper.repository(repo) do |r|
+    def clean(repository = nil)
+      repository = self.db if repository.nil?
+      ::DataMapper.repository(repository) do |r|
         adapter = r.adapter
         while adapter.current_transaction
           adapter.current_transaction.rollback

data/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,4 +1,5 @@
-require "database_cleaner/truncation_base"
+require "database_cleaner/generic/truncation"
+require 'database_cleaner/data_mapper/base'
 
 module DataMapper
   module Adapters
@@ -29,12 +30,13 @@ module DataMapper
           execute("SET FOREIGN_KEY_CHECKS = 0;")
           yield
         ensure
-          execute("SET FOREIGN_KEY_CHECKS = #{old};")
+          execute("SET FOREIGN_KEY_CHECKS = #{old.first};")
         end
       end
 
     end
 
+
     class Sqlite3Adapter < DataObjectsAdapter
 
       # taken from http://github.com/godfat/dm-mapping/tree/master
@@ -46,7 +48,7 @@ module DataMapper
           WHERE type = 'table' AND NOT name = 'sqlite_sequence'
         SQL
         # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
-        select sql
+        select(sql)
       end
 
       def truncate_table(table_name)
@@ -61,7 +63,32 @@ module DataMapper
       end
 
     end
+    
+    class SqliteAdapter < DataObjectsAdapter
+      # taken from http://github.com/godfat/dm-mapping/tree/master
+      def storage_names(repository = :default)
+        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 177
+        sql = <<-SQL.compress_lines
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+        SQL
+        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
+        select(sql)
+      end
 
+      def truncate_table(table_name)
+        execute("DELETE FROM #{quote_name(table_name)};")
+      end
+
+      # this is a no-op copied from activerecord
+      # i didn't find out if/how this is possible
+      # activerecord also doesn't do more here
+      def disable_referential_integrity
+        yield
+      end
+
+    end
 
     # FIXME
     # i don't know if this works
@@ -115,28 +142,34 @@ module DataMapper
 end
 
 
-module DatabaseCleaner::DataMapper
-  class Truncation < ::DatabaseCleaner::TruncationBase
+module DatabaseCleaner
+  module DataMapper
+    class Truncation
+      include ::DatabaseCleaner::DataMapper::Base
+      include ::DatabaseCleaner::Generic::Truncation
 
-    def clean(repository = :default)
-      adapter = DataMapper.repository(repository).adapter
-      adapter.disable_referential_integrity do
-        tables_to_truncate.each do |table_name|
-          adapter.truncate_table table_name
+      def clean(repository = nil)
+        repository = self.db if repository.nil?
+        adapter = ::DataMapper.repository(repository).adapter
+        adapter.disable_referential_integrity do
+          tables_to_truncate(repository).each do |table_name|
+            adapter.truncate_table table_name
+          end
         end
       end
-    end
 
-    private
+      private
 
-    def tables_to_truncate(repository = :default)
-      (@only || DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
-    end
+      def tables_to_truncate(repository = nil)
+        repository = self.db if repository.nil?
+        (@only || ::DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
+      end
 
-    # overwritten
-    def migration_storage_name
-      'migration_info'
-    end
+      # overwritten
+      def migration_storage_name
+        'migration_info'
+      end
 
+    end
   end
 end

data/lib/database_cleaner/generic/base.rb

@@ -0,0 +1,23 @@
+module ::DatabaseCleaner
+   module Generic
+     module Base
+
+       def self.included(base)
+         base.extend(ClassMethods)
+         base.send(:include, InstanceMethods)
+       end
+
+       module InstanceMethods
+         def db
+           :default
+         end
+       end
+
+       module ClassMethods
+         def available_strategies
+           %W[]
+         end
+       end
+     end
+   end
+end

data/lib/database_cleaner/generic/truncation.rb

@@ -0,0 +1,43 @@
+module DatabaseCleaner
+  module Generic
+    module Truncation
+      def self.included(base)
+       base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def initialize(opts={})
+          if !opts.empty? && !(opts.keys - [:only, :except]).empty?
+            raise ArgumentError, "The only valid options are :only and :except. You specified #{opts.keys.join(',')}."
+          end
+          if opts.has_key?(:only) && opts.has_key?(:except)
+            raise ArgumentError, "You may only specify either :only or :either.  Doing both doesn't really make sense does it?"
+          end
+
+          @only = opts[:only]
+          @tables_to_exclude = (opts[:except] || [])
+          @tables_to_exclude << migration_storage_name unless migration_storage_name.nil?
+        end
+
+        def start
+          #included for compatability reasons, do nothing if you don't need to
+        end
+
+        def clean
+          raise NotImplementedError
+        end
+
+        private
+          def tables_to_truncate
+            raise NotImplementedError
+          end
+
+          # overwrite in subclasses
+          # default implementation given because migration storage need not be present
+          def migration_storage_name
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/database_cleaner/mongo_mapper/base.rb

@@ -0,0 +1,20 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module MongoMapper
+    def self.available_strategies
+      %w[truncation]
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      def db=(desired_db)
+        @db = desired_db
+      end
+
+      def db
+        @db || :default
+      end
+    end
+  end
+end