bitfluent-database_cleaner 0.5.2

data/features/step_definitions/database_cleaner_steps.rb

@@ -0,0 +1,25 @@
+Given /^I am using (ActiveRecord|DataMapper|MongoMapper|Mongoid|CouchPotato)$/ do |orm|
+  @orm = orm
+end
+
+Given /^the (.+) cleaning strategy$/ do |strategy|
+  @strategy = strategy
+end
+
+When "I run my scenarios that rely on a clean database" do
+  full_dir ||= File.expand_path(File.dirname(__FILE__) + "/../../examples/")
+  Dir.chdir(full_dir) do
+    ENV['ORM'] = @orm.downcase
+    ENV['STRATEGY'] = @strategy
+    @out = `#{"jruby -S " if defined?(JRUBY_VERSION)}cucumber features`
+    @status = $?.exitstatus
+  end
+end
+
+Then "I should see all green" do
+  unless @status == 0
+    raise "Expected to see all green but we saw FAIL! Output:\n#{@out}"
+  end
+end
+
+

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/lib/database_cleaner.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+require 'database_cleaner/configuration'
+

data/lib/database_cleaner/active_record/transaction.rb

@@ -0,0 +1,26 @@
+module DatabaseCleaner::ActiveRecord
+  class Transaction
+
+    def start
+      if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
+        ActiveRecord::Base.connection.increment_open_transactions
+      else
+        ActiveRecord::Base.__send__(:increment_open_transactions)
+      end
+
+      ActiveRecord::Base.connection.begin_db_transaction
+    end
+
+
+    def clean
+      ActiveRecord::Base.connection.rollback_db_transaction
+
+      if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
+        ActiveRecord::Base.connection.decrement_open_transactions
+      else
+        ActiveRecord::Base.__send__(:decrement_open_transactions)
+      end
+    end
+  end
+
+end

data/lib/database_cleaner/active_record/truncation.rb

@@ -0,0 +1,106 @@
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require "database_cleaner/truncation_base"
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    class AbstractAdapter
+    end
+
+    class SQLiteAdapter < AbstractAdapter
+    end
+
+    class MysqlAdapter < AbstractAdapter
+      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 SQLite3Adapter < SQLiteAdapter
+      def truncate_table(table_name)
+        execute("DELETE FROM #{quote_table_name(table_name)};")
+      end
+    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 self.db_version
+        @db_version ||= ActiveRecord::Base.connection.select_values(
+          "SELECT CHARACTER_VALUE 
+            FROM INFORMATION_SCHEMA.SQL_IMPLEMENTATION_INFO 
+            WHERE IMPLEMENTATION_INFO_NAME = 'DBMS VERSION' ").to_s
+      end
+
+      def self.cascade
+        @cascade ||= db_version >=  "08.02" ? "CASCADE" : ""
+      end
+
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)} #{self.class.cascade};")
+      end
+
+    end
+
+    class SQLServerAdapter < AbstractAdapter
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      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 < ::DatabaseCleaner::TruncationBase
+
+    def clean
+      connection.disable_referential_integrity do
+        tables_to_truncate.each do |table_name|
+          connection.truncate_table table_name
+        end
+      end
+    end
+
+    private
+
+    def tables_to_truncate
+      (@only || connection.tables) - @tables_to_exclude
+    end
+
+    def connection
+      ::ActiveRecord::Base.connection
+    end
+
+    # overwritten
+    def migration_storage_name
+      'schema_migrations'
+    end
+
+  end
+end
+
+

data/lib/database_cleaner/configuration.rb

@@ -0,0 +1,129 @@
+module DatabaseCleaner
+
+  class NoStrategySetError < StandardError;   end
+  class NoORMDetected < StandardError;   end
+  class UnknownStrategySpecified < ArgumentError;   end
+
+  module ActiveRecord
+    def self.available_strategies
+      %w[truncation transaction]
+    end
+  end
+
+  module DataMapper
+    def self.available_strategies
+      %w[truncation transaction]
+    end
+  end
+  
+
+  module MongoMapper
+    def self.available_strategies
+      %w[truncation]
+    end
+  end
+
+  module Mongoid
+    def self.available_strategies
+      %w[truncation]
+    end
+  end
+
+  module CouchPotato
+    def self.available_strategies
+      %w[truncation]
+    end
+  end
+
+  class << self
+
+    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 know strategy along with initialization params."
+       end
+    end
+
+    def orm=(orm_string)
+      @orm = orm_string
+    end
+
+    def start
+      strategy.start
+    end
+
+    def clean
+      strategy.clean
+    end
+
+    alias clean! clean
+
+    private
+
+    def strategy
+      return @strategy if @strategy
+      raise NoStrategySetError, "Please set a strategy with DatabaseCleaner.strategy=."
+    end
+
+    def orm_strategy(strategy)
+  		require "database_cleaner/#{orm}/#{strategy}"
+      orm_module.const_get(strategy.to_s.capitalize)
+    rescue LoadError => e
+      raise UnknownStrategySpecified, "The '#{strategy}' strategy does not exist for the #{orm} ORM!  Available strategies: #{orm_module.available_strategies.join(', ')}"
+    end
+
+
+    def orm
+      @orm ||=begin
+        if defined? ::DataMapper
+          'data_mapper'
+        elsif defined? ::MongoMapper
+          'mongo_mapper'
+        elsif defined? ::Mongoid
+          'mongoid'
+        elsif defined? ::CouchPotato
+          'couch_potato'
+        elsif defined? ::ActiveRecord
+          'active_record'
+        else
+          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord, DataMapper, MongoMapper, Mongoid, or CouchPotato loaded?"
+        end
+      end
+    end
+
+
+    def orm_module
+      case orm
+      when 'active_record'
+        DatabaseCleaner::ActiveRecord
+      when 'data_mapper'
+        DatabaseCleaner::DataMapper
+      when 'mongo_mapper'
+        DatabaseCleaner::MongoMapper
+      when 'mongoid'
+        DatabaseCleaner::Mongoid
+      when 'couch_potato'
+        DatabaseCleaner::CouchPotato
+      end
+    end
+
+  end
+
+end

data/lib/database_cleaner/couch_potato/truncation.rb

@@ -0,0 +1,26 @@
+require 'database_cleaner/truncation_base'
+
+module DatabaseCleaner
+  module CouchPotato
+    class Truncation < DatabaseCleaner::TruncationBase
+      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,8 @@
+
+Before do
+  DatabaseCleaner.start
+end
+
+After do
+  DatabaseCleaner.clean
+end

data/lib/database_cleaner/data_mapper/transaction.rb

@@ -0,0 +1,23 @@
+module DatabaseCleaner::DataMapper
+  class Transaction
+
+    def start(repo = :default)
+      DataMapper.repository(repo) do |r|
+        transaction = DataMapper::Transaction.new(r)
+        transaction.begin
+        r.adapter.push_transaction(transaction)
+      end
+    end
+
+    def clean(repo = :default)
+      DataMapper.repository(repo) 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

@@ -0,0 +1,142 @@
+require "database_cleaner/truncation_base"
+
+module DataMapper
+  module Adapters
+
+    class DataObjectsAdapter
+
+      def storage_names(repository = :default)
+        raise NotImplementedError
+      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.first};")
+        end
+      end
+
+    end
+
+    class Sqlite3Adapter < DataObjectsAdapter
+
+      # 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.compress_lines
+          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)};")
+      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
+
+    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.compress_lines
+          SELECT table_name FROM "information_schema"."tables"
+          WHERE table_schema = current_schema()
+        SQL
+        select(sql)
+      end
+
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_name(table_name)} CASCADE;")
+      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::DataMapper
+  class Truncation < ::DatabaseCleaner::TruncationBase
+
+    def clean(repository = :default)
+      adapter = DataMapper.repository(repository).adapter
+      adapter.disable_referential_integrity do
+        tables_to_truncate.each do |table_name|
+          adapter.truncate_table table_name
+        end
+      end
+    end
+
+    private
+
+    def tables_to_truncate(repository = :default)
+      (@only || DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
+    end
+
+    # overwritten
+    def migration_storage_name
+      'migration_info'
+    end
+
+  end
+end