surgical_strike 0.7.4

data/features/support/env.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'database_cleaner'
+
+require 'spec/expectations'
+
+require 'test/unit/assertions'
+

data/features/support/feature_runner.rb

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

@@ -0,0 +1,53 @@
+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 && File.file?(ActiveRecord.config_file_location)
+          connection_details   = YAML::load(ERB.new(IO.read(ActiveRecord.config_file_location)).result)
+          @connection_hash = connection_details[self.db.to_s]
+        end
+      end
+
+      def create_connection_klass
+        Class.new(::ActiveRecord::Base)
+      end
+
+      def connection_klass
+        return ::ActiveRecord::Base unless connection_hash
+        klass = create_connection_klass
+        klass.send :establish_connection, connection_hash
+        klass
+      end
+    end
+  end
+end

data/lib/database_cleaner/active_record/deletion.rb

@@ -0,0 +1,67 @@
+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 < MYSQL2_ADAPTER_PARENT
+      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
+      connection = connection_klass.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/surgicalstrike.rb

@@ -0,0 +1,65 @@
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'database_cleaner/active_record/base'
+require 'database_cleaner/generic/base'
+require 'SurgicalStrike/generic/surgicalstrike'
+
+module ActiveRecord
+  class Base
+    include ::DatabaseCleaner::Generic::Dataholder
+    extend ActiveRecord::Callbacks
+
+    after_create :add_vip
+
+    private
+    def add_vip
+      checktarget(self)
+    end
+  end
+
+  module ConnectionAdapters
+
+    class AbstractAdapter
+      def views
+        @views ||= select_values("select table_name from information_schema.views where table_schema = '#{current_database}'") rescue []
+      end
+    end
+  end
+end
+
+module DatabaseCleaner::ActiveRecord
+  class Surgicalstrike
+    include ::DatabaseCleaner::ActiveRecord::Base
+    include ::DatabaseCleaner::Generic::Dataholder
+    include ::DatabaseCleaner::Generic::Surgicalstrike
+
+    def start
+      connection = connection_klass.connection
+
+      $strike_targets = tables_to_strike(connection)
+      $vips = Array.new
+    end
+
+    def clean
+      strike_tables
+    end
+
+
+    private
+    def strike_tables
+      $vips = $vips.reverse
+      $vips.each do |record|
+          record.delete
+      end
+    end
+
+    def tables_to_strike(connection)
+      (@only || connection.tables) - @tables_to_exclude - connection.views
+    end
+
+    # overwritten
+    def migration_storage_name
+      'schema_migrations'
+    end
+  end
+end

data/lib/database_cleaner/active_record/transaction.rb

@@ -0,0 +1,28 @@
+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
+      return unless connection_klass.connection.open_transactions > 0
+
+      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

@@ -0,0 +1,152 @@
+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
+
+      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
+
+    unless USE_ARJDBC_WORKAROUND
+      class SQLiteAdapter < AbstractAdapter
+      end
+    end
+
+    # ActiveRecord 3.1 support
+    if defined?(AbstractMysqlAdapter)
+      MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractMysqlAdapter
+      MYSQL2_ADAPTER_PARENT = AbstractMysqlAdapter
+    else
+      MYSQL_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
+      MYSQL2_ADAPTER_PARENT = AbstractAdapter
+    end
+    
+    SQLITE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : SQLiteAdapter
+    POSTGRE_ADAPTER_PARENT = USE_ARJDBC_WORKAROUND ? JdbcAdapter : AbstractAdapter
+
+    class MysqlAdapter < MYSQL_ADAPTER_PARENT
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+    end
+
+    class Mysql2Adapter < MYSQL2_ADAPTER_PARENT
+      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)};")
+        execute("DELETE FROM sqlite_sequence where 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 < POSTGRE_ADAPTER_PARENT
+
+      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
+
+    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
+      connection = connection_klass.connection
+      connection.disable_referential_integrity do
+        connection.truncate_tables(tables_to_truncate(connection))
+      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

@@ -0,0 +1,138 @@
+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?
+      !!@autodetected
+    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
+        elsif defined? ::Sequel
+          :sequel
+        else
+          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, Sequel, MongoMapper, Mongoid, or CouchPotato loaded?"
+        end
+      end
+    end
+
+    def set_default_orm_strategy
+      case orm
+      when :active_record, :data_mapper, :sequel
+        self.strategy = :transaction
+      when :mongo_mapper, :mongoid, :couch_potato
+        self.strategy = :truncation
+      end
+    end
+  end
+end

data/lib/database_cleaner/configuration.rb

@@ -0,0 +1,94 @@
+require 'database_cleaner/base'
+
+module DatabaseCleaner
+
+  class NoORMDetected < StandardError;   end
+  class UnknownStrategySpecified < ArgumentError;   end
+
+  class << self
+    def [](orm,opts = {})
+      raise NoORMDetected unless orm
+      @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)
+      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 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 :couch_potato
+          DatabaseCleaner::CouchPotato
+        when :sequel
+          DatabaseCleaner::Sequel
+      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

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

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