database_cleaner 0.6.7 → 2.0.1

data/lib/database_cleaner/active_record/deletion.rb

@@ -1,64 +0,0 @@
-require 'active_record/base'
-require 'active_record/connection_adapters/abstract_adapter'
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/active_record/truncation'
-# This file may seem to have duplication with that of truncation, but by keeping them separate
-# we avoiding loading this code when it is not being used (which is the common case).
-
-module ActiveRecord
-  module ConnectionAdapters
-
-    class MysqlAdapter < MYSQL_ADAPTER_PARENT
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class Mysql2Adapter < AbstractAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class JdbcAdapter < AbstractAdapter
-      def delete_table(table_name)
-          execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class PostgreSQLAdapter < AbstractAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class SQLServerAdapter < AbstractAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    class OracleEnhancedAdapter < AbstractAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
-      end
-    end
-
-  end
-end
-
-
-module DatabaseCleaner::ActiveRecord
-  class Deletion < Truncation
-
-    def clean
-      each_table do |connection, table_name|
-        connection.delete_table table_name
-      end
-    end
-
-  end
-end
-
-

data/lib/database_cleaner/active_record/transaction.rb

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

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,134 +0,0 @@
-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
-    # Activerecord-jdbc-adapter defines class dependencies a bit differently - if it is present, confirm to ArJdbc hierarchy to avoid 'superclass mismatch' errors.
-    USE_ARJDBC_WORKAROUND = defined?(ArJdbc)
-
-    class AbstractAdapter
-      def views
-        @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
-      end
-    end
-
-    unless USE_ARJDBC_WORKAROUND
-      class SQLiteAdapter < AbstractAdapter
-      end
-    end
-
-    MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
-    SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : SQLiteAdapter
-
-    class MysqlAdapter < MYSQL_ADAPTER_PARENT
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
-    end
-
-    class Mysql2Adapter < AbstractAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
-    end
-
-    class IBM_DBAdapter < AbstractAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
-      end
-    end
-
-    class SQLite3Adapter < SQLITE_ADAPTER_PARENT
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-      alias truncate_table delete_table
-    end
-
-    class JdbcAdapter < AbstractAdapter
-      def truncate_table(table_name)
-        begin
-          execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-        rescue ActiveRecord::StatementInvalid
-          execute("DELETE FROM #{quote_table_name(table_name)};")
-        end
-      end
-    end
-
-    class PostgreSQLAdapter < AbstractAdapter
-
-      def db_version
-        @db_version ||= postgresql_version
-      end
-
-      def cascade
-        @cascade ||= db_version >=  80200 ? 'CASCADE' : ''
-      end
-
-      def restart_identity
-        @restart_identity ||= db_version >=  80400 ? 'RESTART IDENTITY' : ''
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)} #{restart_identity} #{cascade};")
-      end
-
-    end
-
-    class SQLServerAdapter < AbstractAdapter
-      def truncate_table(table_name)
-        begin
-          execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-        rescue ActiveRecord::StatementInvalid
-          execute("DELETE FROM #{quote_table_name(table_name)};")
-        end
-      end
-    end
-
-    class OracleEnhancedAdapter < AbstractAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
-      end
-    end
-
-  end
-end
-
-
-module DatabaseCleaner::ActiveRecord
-  class Truncation
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Truncation
-
-    def clean
-      each_table do |connection, table_name|
-        connection.truncate_table table_name
-      end
-    end
-
-    def each_table
-      connection = connection_klass.connection
-      connection.disable_referential_integrity do
-        tables_to_truncate(connection).each do |table_name|
-          yield connection, table_name
-        end
-      end
-    end
-
-    private
-
-    def tables_to_truncate(connection)
-       (@only || connection.tables) - @tables_to_exclude - connection.views
-    end
-
-    # overwritten
-    def migration_storage_name
-      'schema_migrations'
-    end
-
-  end
-end
-
-

data/lib/database_cleaner/base.rb

@@ -1,136 +0,0 @@
-require 'database_cleaner/null_strategy'
-module DatabaseCleaner
-  class Base
-
-    def initialize(desired_orm = nil,opts = {})
-      if [:autodetect, nil, "autodetect"].include?(desired_orm)
-        autodetect
-      else
-        self.orm = desired_orm
-      end
-      self.db = opts[:connection] if opts.has_key? :connection
-      set_default_orm_strategy
-    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
-    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
-      @strategy || NullStrategy
-    end
-
-    def orm=(desired_orm)
-      @orm = desired_orm.to_sym
-    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
-
-    def set_default_orm_strategy
-      case orm
-      when :active_record, :data_mapper
-        self.strategy = :transaction
-      when :mongo_mapper, :mongoid, :couch_potato
-        self.strategy = :truncation
-      end
-    end
-  end
-end

data/lib/database_cleaner/configuration.rb

@@ -1,92 +0,0 @@
-require 'database_cleaner/base'
-
-module DatabaseCleaner
-
-  class NoORMDetected < StandardError;   end
-  class UnknownStrategySpecified < ArgumentError;   end
-
-  class << self
-    def [](orm,opts = {})
-      raise NoORMDetected if orm.nil?
-      @connections ||= []
-      cleaner = DatabaseCleaner::Base.new(orm,opts)
-      connections.push cleaner
-      cleaner
-    end
-
-    def app_root=(desired_root)
-      @app_root = desired_root
-    end
-
-    def app_root
-      @app_root || Dir.pwd
-    end
-
-    def connections
-      @connections ||= [::DatabaseCleaner::Base.new]
-    end
-    
-    def logger=(log_source)
-      @logger = log_source
-    end
-
-    def logger
-      return @logger if @logger
-      
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::ERROR
-      @logger
-    end
-
-    def strategy=(stratagem)
-      self.connections.each { |connect| connect.strategy = stratagem }
-      remove_duplicates
-    end
-
-    def orm=(orm)
-      self.connections.each { |connect| connect.orm = orm }
-      remove_duplicates
-    end
-
-    def start
-      self.connections.each { |connection| connection.start }
-    end
-
-    def clean
-      self.connections.each { |connection| connection.clean }
-    end
-
-    alias clean! clean
-
-    def clean_with(*args)
-      self.connections.each { |connection| connection.clean_with(*args) }
-    end
-
-    alias clean_with! clean_with
-
-    def remove_duplicates
-      temp = []
-      self.connections.each do |connect|
-        temp.push connect unless temp.include? connect
-      end
-      @connections = temp
-    end
-
-    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

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

data/lib/database_cleaner/couch_potato/truncation.rb

@@ -1,28 +0,0 @@
-require 'database_cleaner/generic/truncation'
-
-module DatabaseCleaner
-  module CouchPotato
-    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."
-        elsif !options.empty?
-          raise ArgumentError, "Unsupported option. You specified #{options.keys.join(',')}."
-        end
-        super
-      end
-
-      def clean
-        database.recreate!
-      end
-
-      private
-
-      def database
-        ::CouchPotato.couchrest_database
-      end
-    end
-  end
-end

data/lib/database_cleaner/cucumber.rb

@@ -1,11 +0,0 @@
-Before do
-  DatabaseCleaner.start
-end
-
-After do
-  begin
-    DatabaseCleaner.clean
-  rescue Exception =>  e
-    DatabaseCleaner.logger.error "Exception encountered by DatabaseCleaner in Cucumber After block: #{e}"
-  end
-end

data/lib/database_cleaner/data_mapper/base.rb

@@ -1,21 +0,0 @@
-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,28 +0,0 @@
-require 'database_cleaner/data_mapper/base'
-
-module DatabaseCleaner::DataMapper
-  class Transaction
-    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(repository = nil)
-      repository = self.db if repository.nil?
-      ::DataMapper.repository(repository) do |r|
-        adapter = r.adapter
-        while adapter.current_transaction
-          adapter.current_transaction.rollback
-          adapter.pop_transaction
-        end
-      end
-    end
-
-  end
-end