database_cleaner 1.6.2 → 2.0.0

data/examples/lib/redis_models.rb

@@ -1,65 +0,0 @@
-require 'redis'
-
-class RedisWidget
-
-  def self.redis
-    threaded ||= Redis.new
-  end
-
-  def self.redis=(connection)
-    threaded = connection
-  end
-
-  def self.threaded
-    Thread.current[self.class.to_s] ||= {}
-  end
-
-  def initialize(options = {})
-    options = options.dup
-    @name = options[:name]
-  end
-
-  def connection
-    self.class.redis
-  end
-
-  def save
-    unless connection.get(self.class.to_s + ':id')
-      @id = 0
-      connection.set(self.class.to_s + ':id', @id)
-    end
-    @id = connection.incr(self.class.to_s + ':id')
-    connection.set(self.class.to_s + ':%d:name' % @id, @name)
-  end
-
-  def self.count
-    self.redis.keys(self.to_s + '*name').size
-  end
-
-  def self.create!
-    new(:name => 'some widget').save
-
-  end
-end
-
-class RedisWidgetUsingDatabaseOne < RedisWidget
-
-  def self.redis
-    threaded[self.class.to_s] ||= Redis.new :url => ENV['REDIS_URL_ONE']
-  end
-
-  def self.create!
-    new(:name => 'a widget using database one').save
-  end
-end
-
-class RedisWidgetUsingDatabaseTwo < RedisWidget
-
-  def self.redis
-    threaded[self.class.to_s] ||= Redis.new :url => ENV['REDIS_URL_TWO']
-  end
-
-  def self.create!
-    new(:name => 'a widget using database two').save
-  end
-end

data/examples/lib/sequel_models.rb

@@ -1,9 +0,0 @@
-require 'sequel'
-
-db = Sequel.sqlite # memory database
-
-db.run 'DROP TABLE IF EXISTS "sequel_widgets"'
-
-db.create_table :sequel_widgets do
-  String :name
-end

data/features/cleaning.feature

@@ -1,30 +0,0 @@
-Feature: database cleaning
-  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 <ORM>
-    And the <Strategy> cleaning strategy
-
-    When I run my scenarios that rely on a clean database
-    Then I should see all green
-
-  Examples:
-    | ORM          | Strategy    |
-    | ActiveRecord | transaction |
-    | ActiveRecord | truncation  |
-    | ActiveRecord | deletion    |
-    | DataMapper   | transaction |
-    | DataMapper   | truncation  |
-    | Sequel       | transaction |
-    | Sequel       | truncation  |
-    | Sequel       | deletion    |
-    | MongoMapper  | truncation  |
-    | Mongoid      | truncation  |
-    | CouchPotato  | truncation  |
-    | Redis        | truncation  |
-    | Ohm          | truncation  |
-    | Neo4j        | deletion    |
-    | Neo4j        | truncation  |
-    | Neo4j        | transaction |

data/features/cleaning_default_strategy.feature

@@ -1,23 +0,0 @@
-Feature: database cleaning
-  In order to ease example and feature writing
-  As a developer
-  I want to have my database in a clean state with default strategy
-
-  Scenario Outline: ruby app
-    Given I am using <ORM>
-    And the default cleaning strategy
-
-    When I run my scenarios that rely on a clean database
-    Then I should see all green
-
-  Examples:
-    | ORM          |
-    | ActiveRecord |
-    | DataMapper   |
-    | Sequel       |
-    | MongoMapper  |
-    | Mongoid      |
-    | CouchPotato  |
-    | Redis        |
-    | Ohm          |
-    | Neo4j        |

data/features/cleaning_multiple_dbs.feature

@@ -1,22 +0,0 @@
-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    |
-  | ActiveRecord | deletion      |
-  | DataMapper   | truncation    |
-  | Sequel       | truncation    |
-  | MongoMapper  | truncation    |
-  | DataMapper   | transaction   |
-  | ActiveRecord | transaction   |
-  | Sequel       | transaction   |

data/features/cleaning_multiple_orms.feature

@@ -1,67 +0,0 @@
-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 | Sequel       |
-    | ActiveRecord | MongoMapper  |
-    | ActiveRecord | Mongoid      |
-    | ActiveRecord | CouchPotato  |
-    | ActiveRecord | Ohm          |
-    | ActiveRecord | Redis        |
-    | DataMapper   | ActiveRecord |
-    | DataMapper   | Sequel       |
-    | DataMapper   | MongoMapper  |
-    | DataMapper   | Mongoid      |
-    | DataMapper   | CouchPotato  |
-    | DataMapper   | Ohm          |
-    | DataMapper   | Redis        |
-    | Sequel       | ActiveRecord |
-    | Sequel       | DataMapper   |
-    | Sequel       | MongoMapper  |
-    | Sequel       | Mongoid      |
-    | Sequel       | CouchPotato  |
-    | Sequel       | Ohm          |
-    | Sequel       | Redis        |
-    | MongoMapper  | ActiveRecord |
-    | MongoMapper  | DataMapper   |
-    | MongoMapper  | Sequel       |
-    | MongoMapper  | Mongoid      |
-    | MongoMapper  | CouchPotato  |
-    | MongoMapper  | Ohm          |
-    | MongoMapper  | Redis        |
-    | CouchPotato  | ActiveRecord |
-    | CouchPotato  | DataMapper   |
-    | CouchPotato  | Sequel       |
-    | CouchPotato  | MongoMapper  |
-    | CouchPotato  | Mongoid      |
-    | CouchPotato  | Ohm          |
-    | CouchPotato  | Redis        |
-    | Ohm          | ActiveRecord |
-    | Ohm          | DataMapper   |
-    | Ohm          | Sequel       |
-    | Ohm          | MongoMapper  |
-    | Ohm          | Mongoid      |
-    | Ohm          | CouchPotato  |
-    | Redis        | ActiveRecord |
-    | Redis        | DataMapper   |
-    | Redis        | Sequel       |
-    | Redis        | MongoMapper  |
-    | Redis        | Mongoid      |
-    | Redis        | CouchPotato  |
-    | Redis        | Ohm          |
-    | Neo4j        | ActiveRecord |
-    | Neo4j        | DataMapper   |
-    | Neo4j        | Sequel       |
-    | Neo4j        | Redis        |
-    | Neo4j        | Ohm          |
-    | Neo4j        | MongoMapper  |

data/features/step_definitions/database_cleaner_steps.rb

@@ -1,33 +0,0 @@
-orms_pattern = /(ActiveRecord|DataMapper|Sequel|MongoMapper|Mongoid|CouchPotato|Redis|Ohm|Neo4j)/
-
-Given /^I am using #{orms_pattern}$/ do |orm|
-  @feature_runner = FeatureRunner.new
-  @feature_runner.orm = orm
-end
-
-Given /^I am using #{orms_pattern} and #{orms_pattern}$/ do |orm1,orm2|
-  @feature_runner = FeatureRunner.new
-  @feature_runner.orm         = orm1
-  @feature_runner.another_orm = orm2
-end
-
-Given /^the (.+) cleaning strategy$/ do |strategy|
-  @feature_runner.strategy = strategy
-end
-
-When "I run my scenarios that rely on a clean database" do
-  @feature_runner.go 'example'
-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/env.rb

@@ -1,4 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'database_cleaner'
-
-require 'rspec/expectations'

data/features/support/feature_runner.rb

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

@@ -1,92 +0,0 @@
-require 'database_cleaner/generic/base'
-require 'active_record'
-require 'erb'
-
-module DatabaseCleaner
-  module ActiveRecord
-
-    def self.available_strategies
-      %w[truncation transaction deletion]
-    end
-
-    def self.config_file_location=(path)
-      @config_file_location = path
-    end
-
-    def self.config_file_location
-      @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
-        if self.db != :default && self.db.is_a?(Symbol) && File.file?(ActiveRecord.config_file_location)
-          connection_details = YAML::load(ERB.new(IO.read(ActiveRecord.config_file_location)).result)
-          @connection_hash   = valid_config(connection_details)[self.db.to_s]
-        end
-      end
-
-      def valid_config(connection_file)
-        if !::ActiveRecord::Base.configurations.nil? && !::ActiveRecord::Base.configurations.empty?
-          if connection_file != ::ActiveRecord::Base.configurations
-            return ::ActiveRecord::Base.configurations
-          end
-        end
-        connection_file
-      end
-
-      def connection_class
-        @connection_class ||= if db && !db.is_a?(Symbol)
-                                db
-                              elsif connection_hash
-                                lookup_from_connection_pool || establish_connection
-                              else
-                                ::ActiveRecord::Base
-                              end
-      end
-
-      def self.migration_table_name
-        if ::ActiveRecord::VERSION::MAJOR < 5
-          ::ActiveRecord::Migrator.schema_migrations_table_name
-        else
-          ::ActiveRecord::SchemaMigration.table_name
-        end
-      end
-
-      def self.exclusion_condition(column_name)
-        result = " #{column_name} <> '#{::DatabaseCleaner::ActiveRecord::Base.migration_table_name}' "
-        if ::ActiveRecord::VERSION::MAJOR >= 5
-          result += " AND #{column_name} <> '#{::ActiveRecord::Base.internal_metadata_table_name}' "
-        end
-        result
-      end
-
-      private
-
-      def lookup_from_connection_pool
-        if ::ActiveRecord::Base.respond_to?(:descendants)
-          database_name = connection_hash["database"] || connection_hash[:database]
-          models        = ::ActiveRecord::Base.descendants
-          models.detect { |m| m.connection_pool.spec.config[:database] == database_name }
-        end
-      end
-
-      def establish_connection
-        ::ActiveRecord::Base.establish_connection(connection_hash)
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/active_record/deletion.rb

@@ -1,106 +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'
-
-module DatabaseCleaner
-  module ConnectionAdapters
-    module AbstractDeleteAdapter
-      def delete_table(table_name)
-        raise NotImplementedError
-      end
-    end
-
-    module GenericDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)};")
-      end
-    end
-
-    module OracleDeleteAdapter
-      def delete_table(table_name)
-        execute("DELETE FROM #{quote_table_name(table_name)}")
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    AbstractAdapter.class_eval { include DatabaseCleaner::ConnectionAdapters::AbstractDeleteAdapter }
-
-    JdbcAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(JdbcAdapter)
-    AbstractMysqlAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(AbstractMysqlAdapter)
-    Mysql2Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(Mysql2Adapter)
-    SQLiteAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLiteAdapter)
-    SQLite3Adapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLite3Adapter)
-    PostgreSQLAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(PostgreSQLAdapter)
-    IBM_DBAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(IBM_DBAdapter)
-    SQLServerAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::GenericDeleteAdapter } if defined?(SQLServerAdapter)
-    OracleEnhancedAdapter.class_eval { include ::DatabaseCleaner::ConnectionAdapters::OracleDeleteAdapter } if defined?(OracleEnhancedAdapter)
-  end
-end
-
-module DatabaseCleaner::ActiveRecord
-  module SelectiveTruncation
-    def tables_to_truncate(connection)
-      if information_schema_exists?(connection)
-        (@only || tables_with_new_rows(connection)) - @tables_to_exclude
-      else
-        super
-      end
-    end
-
-    def tables_with_new_rows(connection)
-      @db_name ||= connection.instance_variable_get('@config')[:database]
-      stats = table_stats_query(connection, @db_name)
-      if stats != ''
-        connection.exec_query(stats).inject([]) {|all, stat| all << stat['table_name'] if stat['exact_row_count'] > 0; all }
-      else
-        []
-      end
-    end
-
-    def table_stats_query(connection, db_name)
-      if @cache_tables && !@table_stats_query.nil?
-        return @table_stats_query
-      else
-        @table_stats_query = connection.select_values(<<-SQL).join(' UNION ')
-               SELECT CONCAT('SELECT \"', table_name, '\" AS table_name, COUNT(*) AS exact_row_count FROM ', table_name)
-               FROM
-               INFORMATION_SCHEMA.TABLES
-               WHERE
-               table_schema = '#{db_name}'
-               AND #{::DatabaseCleaner::ActiveRecord::Base.exclusion_condition('table_name')};
-        SQL
-      end
-    end
-
-    def information_schema_exists? connection
-      return false unless connection.is_a? ActiveRecord::ConnectionAdapters::Mysql2Adapter
-      @information_schema_exists ||=
-        begin
-          connection.execute("SELECT 1 FROM information_schema.tables")
-          true
-        rescue
-          false
-        end
-    end
-  end
-
-  class Deletion < Truncation
-    if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-      include SelectiveTruncation
-    end
-
-    def clean
-      connection = connection_class.connection
-      connection.disable_referential_integrity do
-        tables_to_truncate(connection).each do |table_name|
-          connection.delete_table table_name
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/active_record/transaction.rb

@@ -1,59 +0,0 @@
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/generic/transaction'
-
-module DatabaseCleaner::ActiveRecord
-  class Transaction
-    include ::DatabaseCleaner::ActiveRecord::Base
-    include ::DatabaseCleaner::Generic::Transaction
-
-    def start
-      # Hack to make sure that the connection is properly setup for
-      # the clean code.
-      connection_class.connection.transaction{ }
-
-      if connection_maintains_transaction_count?
-        if connection_class.connection.respond_to?(:increment_open_transactions)
-          connection_class.connection.increment_open_transactions
-        else
-          connection_class.__send__(:increment_open_transactions)
-        end
-      end
-      if connection_class.connection.respond_to?(:begin_transaction)
-        connection_class.connection.begin_transaction :joinable => false
-      else
-        connection_class.connection.begin_db_transaction
-      end
-    end
-
-
-    def clean
-      connection_class.connection_pool.connections.each do |connection|
-        next unless connection.open_transactions > 0
-
-        if connection.respond_to?(:rollback_transaction)
-          connection.rollback_transaction
-        else
-          connection.rollback_db_transaction
-        end
-
-        # The below is for handling after_commit hooks.. see https://github.com/bmabey/database_cleaner/issues/99
-        if connection.respond_to?(:rollback_transaction_records, true)
-          connection.send(:rollback_transaction_records, true)
-        end
-
-        if connection_maintains_transaction_count?
-          if connection.respond_to?(:decrement_open_transactions)
-            connection.decrement_open_transactions
-          else
-            connection_class.__send__(:decrement_open_transactions)
-          end
-        end
-      end
-    end
-
-    def connection_maintains_transaction_count?
-      ActiveRecord::VERSION::MAJOR < 4
-    end
-
-  end
-end