database_cleaner 1.7.0 → 2.0.2

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

data/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,172 +0,0 @@
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/data_mapper/base'
-
-module DataMapper
-  module Adapters
-
-    class DataObjectsAdapter
-
-      def storage_names(repository = :default)
-        raise NotImplementedError
-      end
-
-      def truncate_tables(table_names)
-        table_names.each do |table_name|
-          truncate_table table_name
-        end
-      end
-
-    end
-
-    class MysqlAdapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        select 'SHOW TABLES'
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)};")
-      end
-
-      # copied from activerecord
-      def disable_referential_integrity
-        old = select("SELECT @@FOREIGN_KEY_CHECKS;")
-        begin
-          execute("SET FOREIGN_KEY_CHECKS = 0;")
-          yield
-        ensure
-          execute("SET FOREIGN_KEY_CHECKS = ?", *old)
-        end
-      end
-
-    end
-
-    module SqliteAdapterMethods
-
-      # 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
-          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)};")
-        if uses_sequence?
-          execute("DELETE FROM sqlite_sequence where name = '#{table_name}';")
-        end
-      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
-
-      private
-
-      # Returns a boolean indicating if the SQLite database is using the sqlite_sequence table.
-      def uses_sequence?
-        sql = <<-SQL
-          SELECT name FROM sqlite_master
-          WHERE type='table' AND name='sqlite_sequence'
-        SQL
-        select(sql).first
-      end
-    end
-
-    class SqliteAdapter; include SqliteAdapterMethods; end
-    class Sqlite3Adapter; include SqliteAdapterMethods; end
-
-    # FIXME
-    # i don't know if this works
-    # i basically just copied activerecord code to get a rough idea what they do.
-    # i don't have postgres available, so i won't be the one to write this.
-    # maybe codes below gets some postgres/datamapper user going, though.
-    class PostgresAdapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        sql = <<-SQL
-          SELECT table_name FROM "information_schema"."tables"
-          WHERE table_schema = current_schema() and table_type = 'BASE TABLE'
-        SQL
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)} RESTART IDENTITY CASCADE;")
-      end
-
-      # override to use a single statement
-      def truncate_tables(table_names)
-        quoted_names = table_names.collect { |n| quote_name(n) }.join(', ')
-        execute("TRUNCATE TABLE #{quoted_names} RESTART IDENTITY;")
-      end
-
-      # FIXME
-      # copied from activerecord
-      def supports_disable_referential_integrity?
-        version = select("SHOW server_version")[0][0].split('.')
-        (version[0].to_i >= 8 && version[1].to_i >= 1) ? true : false
-      rescue
-        return false
-      end
-
-      # FIXME
-      # copied unchanged from activerecord
-      def disable_referential_integrity(repository = :default)
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} DISABLE TRIGGER ALL"
-          end.join(";"))
-        end
-        yield
-      ensure
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} ENABLE TRIGGER ALL"
-          end.join(";"))
-        end
-      end
-
-    end
-
-  end
-end
-
-
-module DatabaseCleaner
-  module DataMapper
-    class Truncation
-      include ::DatabaseCleaner::DataMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean(repository = self.db)
-        adapter = ::DataMapper.repository(repository).adapter
-        adapter.disable_referential_integrity do
-          adapter.truncate_tables(tables_to_truncate(repository))
-        end
-      end
-
-      private
-
-      def tables_to_truncate(repository = self.db)
-        (@only || ::DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
-      end
-
-      # overwritten
-      def migration_storage_names
-        %w[migration_info]
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/generic/base.rb

@@ -1,29 +0,0 @@
-module ::DatabaseCleaner
-  module Generic
-    module Base
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      def db
-        :default
-      end
-
-      def cleaning(&block)
-        begin
-          start
-          yield
-        ensure
-          clean
-        end
-      end
-
-      module ClassMethods
-        def available_strategies
-          %W[]
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/generic/transaction.rb

@@ -1,11 +0,0 @@
-module DatabaseCleaner
-  module Generic
-    module Transaction
-      def initialize(opts = {})
-        if !opts.empty?
-          raise ArgumentError, "Options are not available for transaction strategies."
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/generic/truncation.rb

@@ -1,40 +0,0 @@
-module DatabaseCleaner
-  module Generic
-    module Truncation
-      def initialize(opts={})
-        if !opts.empty? && !(opts.keys - [:only, :except, :pre_count, :reset_ids, :cache_tables]).empty?
-          raise ArgumentError, "The only valid options are :only, :except, :pre_count, :reset_ids or :cache_tables. You specified #{opts.keys.join(',')}."
-        end
-        if opts.has_key?(:only) && opts.has_key?(:except)
-          raise ArgumentError, "You may only specify either :only or :except.  Doing both doesn't really make sense does it?"
-        end
-
-        @only = opts[:only]
-        @tables_to_exclude = Array( (opts[:except] || []).dup ).flatten
-        @tables_to_exclude += migration_storage_names
-        @pre_count = opts[:pre_count]
-        @reset_ids = opts[:reset_ids]
-        @cache_tables = opts.has_key?(:cache_tables) ? !!opts[:cache_tables] : true
-      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_names
-        %w[]
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo/base.rb

@@ -1,16 +0,0 @@
-module DatabaseCleaner
-  module Mongo
-    def self.available_strategies
-      %w[truncation]
-    end
-    module Base
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db || raise("You have not specified a database.  (see Mongo::Database)")
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo/truncation.rb

@@ -1,62 +0,0 @@
-require 'database_cleaner/mongo/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/mongo/truncation_mixin'
-module DatabaseCleaner
-  module Mongo
-    class Truncation
-      include ::DatabaseCleaner::Generic::Truncation
-      include TruncationMixin
-      include Base
-      private
-
-      def database
-        db
-      end
-
-      def collections_cache
-        @@collections_cache ||= {}
-      end
-
-      def mongoid_collection_names
-        @@mongoid_collection_names ||= Hash.new{|h,k| h[k]=[]}.tap do |names|
-          ObjectSpace.each_object(Class) do |klass|
-            (names[klass.db.name] << klass.collection_name) if valid_collection_name?(klass)
-          end
-        end
-      end
-
-      def not_caching(db_name, list)
-        @@not_caching ||= {}
-
-        unless @@not_caching.has_key?(db_name)
-          @@not_caching[db_name] = true
-
-          puts "Not caching collection names for db #{db_name}. Missing these from models: #{list}"
-        end
-      end
-
-      def collections
-        return collections_cache[database.name] if collections_cache.has_key?(database.name)
-        db_collections = database.collections.select { |c| c.name !~ /^system\./ }
-
-        missing_collections = mongoid_collection_names[database.name] - db_collections.map(&:name)
-
-        if missing_collections.empty?
-          collections_cache[database.name] = db_collections
-        else
-          not_caching(database.name, missing_collections)
-        end
-
-        db_collections
-      end
-
-      private
-
-      def valid_collection_name?(klass)
-        klass.ancestors.map(&:to_s).include?('Mongoid::Document') &&
-        !klass.embedded &&
-        !klass.collection_name.empty?
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo/truncation_mixin.rb

@@ -1,26 +0,0 @@
-module DatabaseCleaner
-  module Mongo
-    module TruncationMixin
-
-      def clean
-        if @only
-          collections.each { |c| c.send(truncate_method_name) if @only.include?(c.name) }
-        else
-          collections.each { |c| c.send(truncate_method_name) unless @tables_to_exclude.include?(c.name) }
-        end
-        true
-      end
-
-      private
-
-      def collections
-        database.collections.select { |c| c.name !~ /^system\./ }
-      end
-
-      def truncate_method_name
-        # This constant only exists in the 2.x series.
-        defined?(::Mongo::VERSION) ? :delete_many : :remove
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo2/base.rb

@@ -1,16 +0,0 @@
-module DatabaseCleaner
-  module Mongo2
-    def self.available_strategies
-      %w[truncation]
-    end
-    module Base
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db || raise("You have not specified a database.  (see Mongo2::Database)")
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo2/truncation_mixin.rb

@@ -1,39 +0,0 @@
-module DatabaseCleaner
-  module Mongo2
-    module TruncationMixin
-
-      def clean
-        if @only
-          collections.each { |c| database[c].find.delete_many if @only.include?(c) }
-        else
-          collections.each { |c| database[c].find.delete_many unless @tables_to_exclude.include?(c) }
-        end
-        true
-      end
-
-      private
-
-      def database
-        if @db.nil? || @db == :default
-          ::Mongoid::Clients.default
-        else
-          ::Mongoid::Clients.with_name(@db)
-        end
-      end
-
-      def collections
-        if db != :default
-          database.use(db)
-        end
-
-        database.collections.collect { |c| c.namespace.split('.',2)[1] }
-
-        # database['system.namespaces'].find(:name => { '$not' => /\.system\.|\$/ }).to_a.map do |collection|
-        #   _, name = collection['name'].split('.', 2)
-        #   name
-        # end
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/mongo_mapper/base.rb

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

data/lib/database_cleaner/mongo_mapper/truncation.rb

@@ -1,19 +0,0 @@
-require 'database_cleaner/mongo_mapper/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/mongo/truncation_mixin'
-
-module DatabaseCleaner
-  module MongoMapper
-    class Truncation
-      include ::DatabaseCleaner::MongoMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-      include ::DatabaseCleaner::Mongo::TruncationMixin
-      
-      private
-
-      def database
-        ::MongoMapper.database
-      end
-    end
-  end
-end