database_cleaner 1.6.2 → 2.0.0

data/lib/database_cleaner/active_record/truncation.rb

@@ -1,275 +0,0 @@
-require 'active_record/base'
-
-require 'active_record/connection_adapters/abstract_adapter'
-
-#Load available connection adapters
-%w(
-  abstract_mysql_adapter postgresql_adapter sqlite3_adapter mysql_adapter mysql2_adapter
-).each do |known_adapter|
-  begin
-    require "active_record/connection_adapters/#{known_adapter}"
-  rescue LoadError
-  end
-end
-
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/active_record/base'
-
-module DatabaseCleaner
-  module ConnectionAdapters
-
-    module AbstractAdapter
-      # used to be called views but that can clash with gems like schema_plus
-      # this gem is not meant to be exposing such an extra interface any way
-      def database_cleaner_view_cache
-        @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
-      end
-
-      def database_cleaner_table_cache
-        # the adapters don't do caching (#130) but we make the assumption that the list stays the same in tests
-        @database_cleaner_tables ||= ::ActiveRecord::VERSION::MAJOR >= 5 ? data_sources : tables
-      end
-
-      def truncate_table(table_name)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(tables)
-        tables.each do |table_name|
-          self.truncate_table(table_name)
-        end
-      end
-    end
-
-    module AbstractMysqlAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
-      end
-
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      end
-
-      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
-        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
-        truncate_tables(tables.select(&filter))
-      end
-
-      private
-
-      def row_count(table)
-        # Patch for MysqlAdapter with ActiveRecord 3.2.7 later
-        # select_value("SELECT 1") #=> "1"
-        select_value("SELECT EXISTS (SELECT 1 FROM #{quote_table_name(table)} LIMIT 1)").to_i
-      end
-
-      # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
-      # Note, this is different than an empty table since an table may populated, the index increased,
-      # but then the table is cleaned.  In other words, this function tells us if the given table
-      # was ever inserted into.
-      def has_been_used?(table)
-        if has_rows?(table)
-          true
-        else
-          # Patch for MysqlAdapter with ActiveRecord 3.2.7 later
-          # select_value("SELECT 1") #=> "1"
-          select_value(<<-SQL).to_i > 1 # returns nil if not present
-          SELECT Auto_increment
-          FROM information_schema.tables
-          WHERE table_name='#{table}';
-          SQL
-        end
-      end
-
-      def has_rows?(table)
-        row_count(table) > 0
-      end
-    end
-
-    module IBM_DBAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE #{quote_table_name(table_name)} IMMEDIATE")
-      end
-    end
-
-    module SQLiteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-        if uses_sequence
-          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
-        end
-      end
-      alias truncate_table delete_table
-
-      def truncate_tables(tables)
-        tables.each { |t| truncate_table(t) }
-      end
-
-      private
-
-      # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
-      def uses_sequence
-        select_value("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';")
-      end
-    end
-
-    module TruncateOrDelete
-      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
-
-    module OracleAdapter
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_table_name(table_name)}")
-      end
-    end
-
-    module PostgreSQLAdapter
-      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)
-        truncate_tables([table_name])
-      end
-
-      def truncate_tables(table_names)
-        return if table_names.nil? || table_names.empty?
-        execute("TRUNCATE TABLE #{table_names.map{|name| quote_table_name(name)}.join(', ')} #{restart_identity} #{cascade};")
-      end
-
-      def pre_count_truncate_tables(tables, options = {:reset_ids => true})
-        filter = options[:reset_ids] ? method(:has_been_used?) : method(:has_rows?)
-        truncate_tables(tables.select(&filter))
-      end
-
-      def database_cleaner_table_cache
-        # AR returns a list of tables without schema but then returns a
-        # migrations table with the schema. There are other problems, too,
-        # with using the base list. If a table exists in multiple schemas
-        # within the search path, truncation without the schema name could
-        # result in confusing, if not unexpected results.
-        @database_cleaner_tables ||= tables_with_schema
-      end
-
-      private
-
-      # Returns a boolean indicating if the given table has an auto-inc number higher than 0.
-      # Note, this is different than an empty table since an table may populated, the index increased,
-      # but then the table is cleaned.  In other words, this function tells us if the given table
-      # was ever inserted into.
-      def has_been_used?(table)
-        return has_rows?(table) unless has_sequence?(table)
-
-        cur_val = select_value("SELECT currval('#{table}_id_seq');").to_i rescue 0
-        cur_val > 0
-      end
-
-      def has_sequence?(table)
-        select_value("SELECT true FROM pg_class WHERE relname = '#{table}_id_seq';")
-      end
-
-      def has_rows?(table)
-        select_value("SELECT true FROM #{table} LIMIT 1;")
-      end
-
-      def tables_with_schema
-        rows = select_rows <<-_SQL
-          SELECT schemaname || '.' || tablename
-          FROM pg_tables
-          WHERE
-            tablename !~ '_prt_' AND
-            #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('tablename')} AND
-            schemaname = ANY (current_schemas(false))
-        _SQL
-        rows.collect { |result| result.first }
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    #Apply adapter decoraters where applicable (adapter should be loaded)
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractAdapter }
-
-    if defined?(JdbcAdapter)
-      if defined?(OracleJdbcConnection)
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter }
-      else
-        JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete }
-      end
-    end
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(Mysql2Adapter)
-    MysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::AbstractMysqlAdapter } if defined?(MysqlAdapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::SQLiteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::PostgreSQLAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::IBM_DBAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::TruncateOrDelete } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
-
-module DatabaseCleaner::ActiveRecord
-  class Truncation
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Truncation
-
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        if pre_count? && connection.respond_to?(:pre_count_truncate_tables)
-          connection.pre_count_truncate_tables(tables_to_truncate(connection), {:reset_ids => reset_ids?})
-        else
-          connection.truncate_tables(tables_to_truncate(connection))
-        end
-      end
-    end
-
-    private
-
-    def tables_to_truncate(connection)
-      tables_in_db = cache_tables? ? connection.database_cleaner_table_cache : connection.tables
-      to_reject = (@tables_to_exclude + connection.database_cleaner_view_cache)
-      (@only || tables_in_db).reject do |table|
-        if ( m = table.match(/([^.]+)$/) )
-          to_reject.include?(m[1])
-        else
-          false
-        end
-      end
-    end
-
-    # overwritten
-    def migration_storage_names
-      [::DatabaseCleaner::ActiveRecord::Base.migration_table_name]
-    end
-
-    def cache_tables?
-      !!@cache_tables
-    end
-
-    def pre_count?
-      @pre_count == true
-    end
-
-    def reset_ids?
-      @reset_ids != false
-    end
-  end
-end

data/lib/database_cleaner/base.rb

@@ -1,164 +0,0 @@
-require 'database_cleaner/null_strategy'
-module DatabaseCleaner
-  class Base
-    include Comparable
-
-    def <=>(other)
-      (self.orm <=> other.orm) == 0 ? self.db <=> other.db : self.orm <=> other.orm
-    end
-
-    def initialize(desired_orm = nil,opts = {})
-      if [:autodetect, nil, "autodetect"].include?(desired_orm)
-        autodetect
-      else
-        self.orm = desired_orm
-      end
-      self.db = opts[:connection] || opts[:model] if opts.has_key?(:connection) || opts.has_key?(:model)
-      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)
-      set_strategy_db strategy, self.db
-
-      strategy.clean
-      strategy
-    end
-
-    alias clean_with! clean_with
-
-    def set_strategy_db(strategy, 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 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
-
-       set_strategy_db @strategy, 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 cleaning(&block)
-      strategy.cleaning(&block)
-    end
-
-    def auto_detected?
-      !!@autodetected
-    end
-
-    def autodetect_orm
-      if defined? ::ActiveRecord
-        :active_record
-      elsif defined? ::DataMapper
-        :data_mapper
-      elsif defined? ::MongoMapper
-        :mongo_mapper
-      elsif defined? ::Mongoid
-        :mongoid
-      elsif defined? ::CouchPotato
-        :couch_potato
-      elsif defined? ::Sequel
-        :sequel
-      elsif defined? ::Moped
-        :moped
-      elsif defined? ::Ohm
-        :ohm
-      elsif defined? ::Redis
-        :redis
-      elsif defined? ::Neo4j
-        :neo4j
-      end
-    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
-      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
-      @autodetected = true
-
-      @orm ||= autodetect_orm ||
-               raise(NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, Sequel, MongoMapper, Mongoid, Moped, or CouchPotato, Redis or Ohm loaded?")
-    end
-
-    def set_default_orm_strategy
-      case orm
-      when :active_record, :data_mapper, :sequel
-        self.strategy = :transaction
-      when :mongo_mapper, :mongoid, :couch_potato, :moped, :ohm, :redis
-        self.strategy = :truncation
-      when :neo4j
-        self.strategy = :transaction
-      end
-    end
-  end
-end

data/lib/database_cleaner/configuration.rb

@@ -1,131 +0,0 @@
-require 'database_cleaner/base'
-
-module DatabaseCleaner
-
-  class NoORMDetected < StandardError;   end
-  class UnknownStrategySpecified < ArgumentError;   end
-
-  class << self
-    def init_cleaners
-      @cleaners ||= {}
-      # ghetto ordered hash.. maintains 1.8 compat and old API
-      @connections ||= []
-    end
-
-    def [](orm,opts = {})
-      raise NoORMDetected unless orm
-      init_cleaners
-      # TODO: deprecate
-      # this method conflates creation with lookup.  Both a command and a query. Yuck.
-      if @cleaners.has_key? [orm, opts]
-        @cleaners[[orm, opts]]
-      else
-        add_cleaner(orm, opts)
-      end
-    end
-
-    def add_cleaner(orm,opts = {})
-      init_cleaners
-      cleaner = DatabaseCleaner::Base.new(orm,opts)
-      @cleaners[[orm, opts]] = cleaner
-      @connections << cleaner
-      cleaner
-    end
-
-    def app_root=(desired_root)
-      @app_root = desired_root
-    end
-
-    def app_root
-      @app_root ||= Dir.pwd
-    end
-
-    def connections
-      # double yuck.. can't wait to deprecate this whole class...
-      unless defined?(@cleaners) && @cleaners
-        autodetected = ::DatabaseCleaner::Base.new
-        add_cleaner(autodetected.orm)
-      end
-      @connections
-    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)
-      connections.each { |connect| connect.strategy = stratagem }
-      remove_duplicates
-    end
-
-    def orm=(orm)
-      connections.each { |connect| connect.orm = orm }
-      remove_duplicates
-    end
-
-    def start
-      connections.each { |connection| connection.start }
-    end
-
-    def clean
-      connections.each { |connection| connection.clean }
-    end
-
-    alias clean! clean
-
-    def cleaning(&inner_block)
-      connections.inject(inner_block) do |curr_block, connection|
-        proc { connection.cleaning(&curr_block) }
-      end.call
-    end
-
-    def clean_with(*args)
-      connections.each { |connection| connection.clean_with(*args) }
-    end
-
-    alias clean_with! clean_with
-
-    def remove_duplicates
-      temp = []
-      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 :moped
-          DatabaseCleaner::Moped
-        when :couch_potato
-          DatabaseCleaner::CouchPotato
-        when :sequel
-          DatabaseCleaner::Sequel
-        when :ohm
-          DatabaseCleaner::Ohm
-        when :redis
-          DatabaseCleaner::Redis
-        when :neo4j
-          DatabaseCleaner::Neo4j
-      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,3 +0,0 @@
-Around do |scenario, block|
-  DatabaseCleaner.cleaning(&block)
-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'
-require 'database_cleaner/generic/transaction'
-
-module DatabaseCleaner::DataMapper
-  class Transaction
-    include ::DatabaseCleaner::DataMapper::Base
-    include ::DatabaseCleaner::Generic::Transaction
-
-    def start(repository = self.db)
-      ::DataMapper.repository(repository) do |r|
-        transaction = DataMapper::Transaction.new(r)
-        transaction.begin
-        r.adapter.push_transaction(transaction)
-      end
-    end
-
-    def clean(repository = self.db)
-      ::DataMapper.repository(repository) do |r|
-        adapter = r.adapter
-        while adapter.current_transaction
-          adapter.current_transaction.rollback
-          adapter.pop_transaction
-        end
-      end
-    end
-
-  end
-end