surgical_strike 0.7.4

data/lib/database_cleaner/data_mapper/base.rb

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

@@ -0,0 +1,26 @@
+require 'database_cleaner/data_mapper/base'
+
+module DatabaseCleaner::DataMapper
+  class Transaction
+    include ::DatabaseCleaner::DataMapper::Base
+
+    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

@@ -0,0 +1,175 @@
+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
+
+    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
+
+
+    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
+          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)};")
+        execute("DELETE FROM sqlite_sequence where 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
+
+    class SqliteAdapter < 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
+          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)};")
+        execute("DELETE FROM sqlite_sequence where 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
+          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
+
+      # 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
+          tables_to_truncate(repository).each do |table_name|
+            adapter.truncate_table table_name
+          end
+        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_name
+        'migration_info'
+      end
+
+    end
+  end
+end

data/lib/database_cleaner/generic/base.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+require 'database_cleaner/active_record/base'
+require 'erb'
+
+module DatabaseCleaner
+  module ActiveRecord
+
+    def self.available_strategies
+      %w[truncation transaction deletion surgicalstrike]
+    end
+  end
+end

data/lib/database_cleaner/generic/surgicalstrike.rb

@@ -0,0 +1,47 @@
+require "database_cleaner"
+
+module DatabaseCleaner
+  module Generic
+    module Dataholder
+      def checktarget(target)
+        if ($strike_targets.include?(target.class.table_name.upcase))
+          $vips.push(target)
+        end
+      end
+    end
+    module Surgicalstrike
+      def initialize(opts={})
+        if !opts.empty? && !(opts.keys - [:only, :except]).empty?
+          raise ArgumentError, "The only valid options are :only and :except. 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 = (opts[:except] || []).dup
+        @tables_to_exclude << migration_storage_name if migration_storage_name
+      end
+
+      def start
+        raise NotImplementedError
+      end
+
+      def clean
+        raise NotImplementedError
+      end
+
+      private
+
+      def tables_to_strike(connection)
+        raise NotImplementedError
+      end
+
+      # overwrite in subclasses
+      # default implementation given because migration storage need not be present
+      def migration_storage_name
+        nil
+      end
+    end
+  end
+end

data/lib/database_cleaner/generic/truncation.rb

@@ -0,0 +1,37 @@
+module DatabaseCleaner
+  module Generic
+    module Truncation
+      def initialize(opts={})
+        if !opts.empty? && !(opts.keys - [:only, :except]).empty?
+          raise ArgumentError, "The only valid options are :only and :except. 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 = (opts[:except] || []).dup
+        @tables_to_exclude << migration_storage_name if migration_storage_name
+      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_name
+        nil
+      end
+    end
+  end
+end

data/lib/database_cleaner/mongo/truncation.rb

@@ -0,0 +1,22 @@
+module DatabaseCleaner
+  module Mongo
+    module Truncation
+
+      def clean
+        if @only
+          collections.each { |c| c.remove if @only.include?(c.name) }
+        else
+          collections.each { |c| c.remove unless @tables_to_exclude.include?(c.name) }
+        end
+        true
+      end
+
+      private
+
+      def collections
+        database.collections.select { |c| c.name !~ /^system\./ }
+      end
+
+    end
+  end
+end

data/lib/database_cleaner/mongo_mapper/base.rb

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

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

data/lib/database_cleaner/mongoid/base.rb

@@ -0,0 +1,20 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module Mongoid
+    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/mongoid/truncation.rb

@@ -0,0 +1,20 @@
+require 'database_cleaner/mongoid/base'
+require 'database_cleaner/generic/truncation'
+require 'database_cleaner/mongo/truncation'
+
+module DatabaseCleaner
+  module Mongoid
+    class Truncation
+      include ::DatabaseCleaner::Mongoid::Base
+      include ::DatabaseCleaner::Generic::Truncation
+      include ::DatabaseCleaner::Mongo::Truncation
+
+      private
+
+      def database
+        ::Mongoid.database
+      end
+
+  end
+  end
+end

data/lib/database_cleaner/null_strategy.rb

@@ -0,0 +1,15 @@
+module DatabaseCleaner
+  class NullStrategy
+    def self.start
+      # no-op
+    end
+    
+     def self.db=(connection)
+       # no-op
+     end
+     
+    def self.clean
+      # no-op
+    end
+  end
+end

data/lib/database_cleaner/sequel/base.rb

@@ -0,0 +1,22 @@
+require 'database_cleaner/generic/base'
+module DatabaseCleaner
+  module Sequel
+    def self.available_strategies
+      %w[truncation transaction]
+    end
+
+    module Base
+      include ::DatabaseCleaner::Generic::Base
+
+      def db=(desired_db)
+        @db = desired_db
+      end
+
+      def db
+        return @db if @db && @db != :default
+        raise "As you have more than one active sequel database you have to specify the one to use manually!" if ::Sequel::DATABASES.count > 1 
+        ::Sequel::DATABASES.first || :default
+      end
+    end
+  end
+end

data/lib/database_cleaner/sequel/transaction.rb

@@ -0,0 +1,25 @@
+require 'database_cleaner/sequel/base'
+module DatabaseCleaner
+  module Sequel
+    class Transaction
+      include ::DatabaseCleaner::Sequel::Base
+
+      def start
+        @fibers||= []
+        db= self.db
+        f= Fiber.new do
+          db.transaction(:rollback => :always, :savepoint => true) do
+            Fiber.yield
+          end
+        end
+        f.resume
+        @fibers<< f
+      end
+
+      def clean
+        f= @fibers.pop
+        f.resume
+      end
+    end
+  end
+end

data/lib/database_cleaner/sequel/truncation.rb

@@ -0,0 +1,50 @@
+require "database_cleaner/generic/truncation"
+require 'database_cleaner/sequel/base'
+
+module DatabaseCleaner
+  module Sequel
+    class Truncation
+      include ::DatabaseCleaner::Sequel::Base
+      include ::DatabaseCleaner::Generic::Truncation
+  
+      def clean
+        case db_type= db.url.sub(/:.+/,'').to_sym
+        when :postgres
+          # PostgreSQL requires all tables with FKs to be truncates in the same command, or have the CASCADE keyword
+          # appended. Bulk truncation without CASCADE is:
+          # * Safer. Tables outside of tables_to_truncate won't be affected.
+          # * Faster. Less roundtrips to the db.
+          unless (tables= tables_to_truncate(db)).empty?
+            all_tables= tables.map{|t| %["#{t}"]}.join ','
+            db.run "TRUNCATE TABLE #{all_tables};"
+          end
+        else
+          # Truncate each table normally
+          each_table do |db, table|
+            db[table].truncate
+          end
+        end
+      end
+  
+      def each_table
+        tables_to_truncate(db).each do |table|
+          yield db, table
+        end
+      end
+
+      private
+  
+      def tables_to_truncate(db)
+        (@only || db.tables) - @tables_to_exclude
+      end
+
+      # overwritten
+      def migration_storage_name
+        :schema_info
+      end
+
+    end
+  end
+end
+
+

data/lib/surgical_strike.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/spec/database_cleaner/active_record/base_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'active_record'
+require 'database_cleaner/active_record/base'
+require 'database_cleaner/shared_strategy_spec'
+
+module DatabaseCleaner
+  describe ActiveRecord do
+    it { should respond_to(:available_strategies) }
+
+    describe "config_file_location" do
+      subject { ActiveRecord.config_file_location }
+
+      it "should default to DatabaseCleaner.root / config / database.yml" do
+        ActiveRecord.config_file_location=nil
+        DatabaseCleaner.should_receive(:app_root).and_return("/path/to")
+        subject.should == '/path/to/config/database.yml'
+      end
+    end
+
+  end
+
+  module ActiveRecord
+    class ExampleStrategy
+      include ::DatabaseCleaner::ActiveRecord::Base
+    end
+
+    describe ExampleStrategy do
+      let :config_location do
+        '/path/to/config/database.yml'
+      end
+
+      before { ::DatabaseCleaner::ActiveRecord.stub(:config_file_location).and_return(config_location) }
+
+      it_should_behave_like "a generic strategy"
+
+      describe "db" do
+
+        it "should store my desired db" do
+          subject.stub(:load_config)
+
+          subject.db = :my_db
+          subject.db.should == :my_db
+        end
+
+        it "should default to :default" do
+          subject.db.should == :default
+        end
+
+        it "should load_config when I set db" do
+          subject.should_receive(:load_config)
+          subject.db = :my_db
+        end
+      end
+
+      describe "load_config" do
+
+        before do
+          subject.db = :my_db
+          yaml = <<-Y
+my_db:
+  database: <%= "ONE".downcase %>
+          Y
+          File.stub(:file?).with(config_location).and_return(true)
+          IO.stub(:read).with(config_location).and_return(yaml)
+        end
+
+        it "should parse the config" do
+          YAML.should_receive(:load).and_return( {:nil => nil} )
+          subject.load_config
+        end
+
+        it "should process erb in the config" do
+          transformed = <<-Y
+my_db:
+  database: one
+          Y
+          YAML.should_receive(:load).with(transformed).and_return({ "my_db" => {"database" => "one"} })
+          subject.load_config
+        end
+
+        it "should store the relevant config in connection_hash" do
+          subject.load_config
+          subject.connection_hash.should == {"database" => "one"}
+        end
+
+        it "should skip config if config file is not available" do
+          File.should_receive(:file?).with(config_location).and_return(false)
+          subject.load_config
+          subject.connection_hash.should be_blank
+        end
+
+        it "skips the file when the db is set to :default" do
+          # to avoid https://github.com/bmabey/database_cleaner/issues/72
+          subject.db = :default
+          YAML.should_not_receive(:load)
+          subject.load_config
+        end
+
+      end
+
+      describe "connection_hash" do
+        it "should store connection_hash" do
+          subject.connection_hash = { :key => "value" }
+          subject.connection_hash.should == { :key => "value" }
+        end
+      end
+
+      describe "create_connection_klass" do
+        it "should return a class" do
+          subject.create_connection_klass.should be_a(Class)
+        end
+
+        it "should return a class extending ::ActiveRecord::Base" do
+          subject.create_connection_klass.ancestors.should include(::ActiveRecord::Base)
+        end
+      end
+
+      describe "connection_klass" do
+        it { expect{ subject.connection_klass }.to_not raise_error }
+        it "should default to ActiveRecord::Base" do
+          subject.connection_klass.should == ::ActiveRecord::Base
+        end
+
+        context "when connection_hash is set" do
+          let(:hash) { mock("hash") }
+          before { subject.stub(:connection_hash).and_return(hash) }
+
+          it "should create connection_klass if it doesnt exist if connection_hash is set" do
+            subject.should_receive(:create_connection_klass).and_return(mock('class').as_null_object)
+            subject.connection_klass
+          end
+
+          it  "should configure the class from create_connection_klass if connection_hash is set" do
+            klass = mock('klass')
+            klass.should_receive(:establish_connection).with(hash)
+
+            subject.should_receive(:create_connection_klass).and_return(klass)
+            subject.connection_klass
+          end
+        end
+      end
+    end
+  end
+end