database_cleaner 1.6.2 → 2.0.2

data/lib/database_cleaner/neo4j/deletion.rb

@@ -1,16 +0,0 @@
-require 'database_cleaner/neo4j/base'
-require 'neo4j-core'
-
-module DatabaseCleaner
-  module Neo4j
-    class Deletion
-      include ::DatabaseCleaner::Neo4j::Base
-
-      def clean
-        ::Neo4j::Transaction.run do
-          session._query('MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r')
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/neo4j/transaction.rb

@@ -1,35 +0,0 @@
-require 'database_cleaner/neo4j/base'
-require 'database_cleaner/generic/transaction'
-require 'neo4j-core'
-
-module DatabaseCleaner
-  module Neo4j
-    class Transaction
-      include ::DatabaseCleaner::Generic::Transaction
-      include ::DatabaseCleaner::Neo4j::Base
-
-      attr_accessor :tx
-
-      def start
-        super
-        rollback
-        self.tx = ::Neo4j::Transaction.new
-      end
-
-      def clean
-        rollback
-      end
-
-      private
-
-      def rollback
-        if tx
-          tx.failure
-          tx.close
-        end
-      ensure
-        self.tx = nil
-      end
-    end
-  end
-end

data/lib/database_cleaner/neo4j/truncation.rb

@@ -1,9 +0,0 @@
-require 'database_cleaner/neo4j/base'
-require 'database_cleaner/neo4j/deletion'
-
-module DatabaseCleaner
-  module Neo4j
-    class Truncation < DatabaseCleaner::Neo4j::Deletion
-    end
-  end
-end

data/lib/database_cleaner/null_strategy.rb

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

data/lib/database_cleaner/ohm/truncation.rb

@@ -1,15 +0,0 @@
-require 'database_cleaner/redis/truncation'
-
-module DatabaseCleaner
-  module Ohm
-    class Truncation < ::DatabaseCleaner::Redis::Truncation
-
-      private
-
-      def default_redis
-        ::Ohm.redis
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/redis/base.rb

@@ -1,37 +0,0 @@
-require 'database_cleaner/generic/base'
-
-module DatabaseCleaner
-  module Redis
-    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
-
-      alias url db
-
-      private
-
-      def connection
-        @connection ||= begin
-          if url == :default
-            ::Redis.new
-          elsif db.is_a?(::Redis) # pass directly the connection
-            db
-          else
-            ::Redis.new(:url => url)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/redis/truncation.rb

@@ -1,26 +0,0 @@
-require 'database_cleaner/redis/base'
-require 'database_cleaner/generic/truncation'
-
-module DatabaseCleaner
-  module Redis
-    class Truncation
-      include ::DatabaseCleaner::Redis::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean
-        if @only
-          @only.each do |term|
-            connection.keys(term).each { |k| connection.del k }
-          end
-        elsif @tables_to_exclude
-          keys_except = []
-          @tables_to_exclude.each { |term| keys_except += connection.keys(term) }
-          connection.keys.each { |k| connection.del(k) unless keys_except.include?(k) }
-        else
-          connection.flushdb
-        end
-        connection.quit unless url == :default
-      end
-    end
-  end
-end

data/lib/database_cleaner/sequel/base.rb

@@ -1,22 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module Sequel
-    def self.available_strategies
-      %w(truncation transaction deletion)
-    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/deletion.rb

@@ -1,47 +0,0 @@
-require 'database_cleaner/sequel/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/sequel/truncation'
-
-module DatabaseCleaner::Sequel
-  class Deletion < Truncation
-    def disable_referential_integrity(tables)
-      case db.database_type
-      when :postgres
-        db.run('SET CONSTRAINTS ALL DEFERRED')
-        tables_to_truncate(db).each do |table|
-          db.run("ALTER TABLE \"#{table}\" DISABLE TRIGGER ALL")
-        end
-      when :mysql
-        old = db.fetch('SELECT @@FOREIGN_KEY_CHECKS').first[:@@FOREIGN_KEY_CHECKS]
-        db.run('SET FOREIGN_KEY_CHECKS = 0')
-      end
-      yield
-    ensure
-      case db.database_type
-      when :postgres
-        tables.each do |table|
-          db.run("ALTER TABLE \"#{table}\" ENABLE TRIGGER ALL")
-        end
-      when :mysql
-        db.run("SET FOREIGN_KEY_CHECKS = #{old}")
-      end
-    end
-
-    def delete_tables(db, tables)
-      tables.each do |table|
-        db[table.to_sym].delete
-      end
-    end
-
-    def clean
-      return unless dirty?
-
-      tables = tables_to_truncate(db)
-      db.transaction do
-        disable_referential_integrity(tables) do
-          delete_tables(db, tables)
-        end
-      end
-    end
-  end
-end

data/lib/database_cleaner/sequel/transaction.rb

@@ -1,40 +0,0 @@
-require 'database_cleaner/sequel/base'
-module DatabaseCleaner
-  module Sequel
-    class Transaction
-      include ::DatabaseCleaner::Sequel::Base
-
-      def self.check_fiber_brokenness
-        if !@checked_fiber_brokenness && Fiber.new { Thread.current }.resume != Thread.current
-          raise RuntimeError, "This ruby engine's Fibers are not compatible with Sequel's connection pool. " +
-            "To work around this, please use DatabaseCleaner.cleaning with a block instead of " +
-            "DatabaseCleaner.start and DatabaseCleaner.clean"
-        end
-        @checked_fiber_brokenness = true
-      end
-
-      def start
-        self.class.check_fiber_brokenness
-
-        @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
-
-      def cleaning
-        self.db.transaction(:rollback => :always, :savepoint => true) { yield }
-      end
-    end
-  end
-end

data/lib/database_cleaner/sequel/truncation.rb

@@ -1,78 +0,0 @@
-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 start
-        @last_txid = txid
-      end
-
-      def clean
-        return unless dirty?
-
-        case db.database_type
-        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
-          tables = tables_to_truncate(db)
-
-          if pre_count?
-            # Count rows before truncating
-            pre_count_truncate_tables(db, tables)
-          else
-            # Truncate each table normally
-            truncate_tables(db, tables)
-          end
-        end
-      end
-
-      private
-
-      def pre_count_truncate_tables(db, tables)
-        tables = tables.reject { |table| db[table.to_sym].count == 0 }
-        truncate_tables(db, tables)
-      end
-
-      def truncate_tables(db, tables)
-        tables.each do |table|
-          db[table.to_sym].truncate
-        end
-      end
-
-      def dirty?
-        @last_txid != txid || @last_txid.nil?
-      end
-
-      def txid
-        case db.database_type
-        when :postgres
-          db.fetch('SELECT txid_snapshot_xmax(txid_current_snapshot()) AS txid').first[:txid]
-        end
-      end
-
-      def tables_to_truncate(db)
-        (@only || db.tables.map(&:to_s)) - @tables_to_exclude
-      end
-
-      # overwritten
-      def migration_storage_names
-        %w(schema_info schema_migrations)
-      end
-
-      def pre_count?
-        @pre_count == true
-      end
-    end
-  end
-end

data/spec/database_cleaner/active_record/base_spec.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/shared_strategy'
-
-class FakeModel
-  def self.connection
-    :fake_connection
-  end
-end
-
-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 eq '/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 eq :my_db
-        end
-
-        it "should default to :default" do
-          subject.db.should eq :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
-
-        context 'use ActiveRecord::Base.configuration' do
-          it 'when config file different with it' do
-            ::ActiveRecord::Base.stub(:configurations).and_return({ "my_db" =>{ "database" => "two"} })
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "two"})
-          end
-        end
-
-        context 'use config file' do
-          it 'when config file same with it' do
-            ::ActiveRecord::Base.stub(:configurations).and_return({ "my_db" =>{ "database" => "one"} })
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "one"})
-          end
-
-          it 'when ::ActiveRecord::Base.configurations nil' do
-            ::ActiveRecord::Base.stub(:configurations).and_return(nil)
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "one"})
-          end
-
-          it 'when ::ActiveRecord::Base.configurations empty' do
-            ::ActiveRecord::Base.stub(:configurations).and_return({})
-            subject.load_config
-            subject.connection_hash.should eq({ "database" => "one"})
-          end
-        end
-
-        it "should store the relevant config in connection_hash" do
-          subject.load_config
-          subject.connection_hash.should eq( "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_not be
-        end
-
-        it "skips the file when the model is set" do
-          subject.db = FakeModel
-          YAML.should_not_receive(:load)
-          subject.load_config
-          subject.connection_hash.should_not be
-        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
-          subject.connection_hash.should_not be
-        end
-
-      end
-
-      describe "connection_hash" do
-        it "should store connection_hash" do
-          subject.connection_hash = { :key => "value" }
-          subject.connection_hash.should eq( :key => "value" )
-        end
-      end
-
-      describe "connection_class" do
-        it { expect { subject.connection_class }.to_not raise_error }
-        it "should default to ActiveRecord::Base" do
-          subject.connection_class.should eq ::ActiveRecord::Base
-        end
-
-        context "with database models" do
-          context "connection_hash is set" do
-            it "allows for database models to be passed in" do
-              subject.db = FakeModel
-              subject.connection_hash = { }
-              subject.load_config
-              subject.connection_class.should eq FakeModel
-            end
-          end
-
-          context "connection_hash is not set" do
-            it "allows for database models to be passed in" do
-              subject.db = FakeModel
-              subject.connection_class.should eq FakeModel
-            end
-          end
-        end
-
-        context "when connection_hash is set" do
-          let(:hash) { double("hash") }
-          before { ::ActiveRecord::Base.stub(:respond_to?).and_return(false) }
-          before { subject.stub(:connection_hash).and_return(hash) }
-
-          it "establish a connection using ActiveRecord::Base" do
-            ::ActiveRecord::Base.should_receive(:establish_connection).with(hash)
-
-            subject.connection_class
-          end
-        end
-      end
-    end
-  end
-end