database_cleaner 1.6.2 → 1.8.5

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/mongo2/base.rb

@@ -1,16 +0,0 @@
-module DatabaseCleaner
-  module Mongo2
-    def self.available_strategies
-      %w[truncation]
-    end
-    module Base
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db || raise("You have not specified a database.  (see Mongo2::Database)")
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo_mapper/truncation.rb

@@ -1,19 +0,0 @@
-require 'database_cleaner/mongo_mapper/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/mongo/truncation_mixin'
-
-module DatabaseCleaner
-  module MongoMapper
-    class Truncation
-      include ::DatabaseCleaner::MongoMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-      include ::DatabaseCleaner::Mongo::TruncationMixin
-      
-      private
-
-      def database
-        ::MongoMapper.database
-      end
-    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/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

data/spec/database_cleaner/active_record/transaction_spec.rb

@@ -1,176 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'database_cleaner/active_record/transaction'
-require 'active_record'
-
-module DatabaseCleaner
-  module ActiveRecord
-
-    describe Transaction do
-      let (:connection) { double("connection") }
-      let (:connection_2) { double("connection") }
-      let (:connection_pool) { double("connection_pool")}
-      before(:each) do
-        ::ActiveRecord::Base.stub(:connection_pool).and_return(connection_pool)
-        connection_pool.stub(:connections).and_return([connection])
-        ::ActiveRecord::Base.stub(:connection).and_return(connection)
-      end
-
-      describe "#start" do
-        [:begin_transaction, :begin_db_transaction].each do |begin_transaction_method|
-          context "using #{begin_transaction_method}" do
-            before do
-              connection.stub(:transaction)
-              connection.stub(begin_transaction_method)
-              connection.stub(:respond_to?).with(:begin_transaction).and_return(:begin_transaction == begin_transaction_method)
-            end
-
-            it "should increment open transactions if possible" do
-              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(true)
-              connection.should_receive(:increment_open_transactions)
-              Transaction.new.start
-            end
-
-            it "should tell ActiveRecord to increment connection if its not possible to increment current connection" do
-              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(false)
-              ::ActiveRecord::Base.should_receive(:increment_open_transactions)
-              Transaction.new.start
-            end
-
-            it "should start a transaction" do
-              connection.stub(:respond_to?).with(:increment_open_transactions).and_return(true)
-              connection.stub(:increment_open_transactions)
-              connection.should_receive(begin_transaction_method)
-              connection.should_receive(:transaction)
-              Transaction.new.start
-            end
-          end
-        end
-      end
-
-      describe "#clean" do
-        context "manual accounting of transaction count" do
-          it "should start a transaction" do
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.stub(:decrement_open_transactions)
-
-            connection.should_receive(:rollback_db_transaction)
-            Transaction.new.clean
-          end
-
-          it "should decrement open transactions if possible" do
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(true)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            connection.should_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-
-          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
-            connection.should_receive(:open_transactions).and_return(0)
-
-            Transaction.new.clean
-          end
-
-          it "should decrement connection via ActiveRecord::Base if connection won't" do
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-
-          it "should rollback open transactions in all connections" do
-            connection_pool.stub(:connections).and_return([connection, connection_2])
-
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            connection_2.should_receive(:open_transactions).and_return(1)
-            connection_2.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection_2.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection_2.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection_2.stub(:rollback_db_transaction)
-
-            ::ActiveRecord::Base.should_receive(:decrement_open_transactions).twice
-            Transaction.new.clean
-          end
-
-          it "should rollback open transactions in all connections with an open transaction" do
-            connection_pool.stub(:connections).and_return([connection, connection_2])
-
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:decrement_open_transactions).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(false)
-            connection.stub(:rollback_db_transaction)
-
-            connection_2.should_receive(:open_transactions).and_return(0)
-
-            ::ActiveRecord::Base.should_receive(:decrement_open_transactions).exactly(1).times
-            Transaction.new.clean
-          end
-        end
-
-        context "automatic accounting of transaction count (AR 4)" do
-          before {stub_const("ActiveRecord::VERSION::MAJOR", 4) }
-
-          it "should start a transaction" do
-            connection.stub(:rollback_db_transaction)
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.should_not_receive(:decrement_open_transactions)
-            connection.should_receive(:rollback_transaction)
-            Transaction.new.clean
-          end
-
-          it "should decrement open transactions if possible" do
-            connection.stub(:rollback_transaction)
-            connection.should_receive(:open_transactions).and_return(1)
-
-            connection.should_not_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-
-          it "should not try to decrement or rollback if open_transactions is 0 for whatever reason" do
-            connection.should_receive(:open_transactions).and_return(0)
-
-            Transaction.new.clean
-          end
-
-          it "should decrement connection via ActiveRecord::Base if connection won't" do
-            connection.should_receive(:open_transactions).and_return(1)
-            connection.stub(:respond_to?).with(:rollback_transaction_records, true).and_return(false)
-            connection.stub(:respond_to?).with(:rollback_transaction).and_return(true)
-            connection.stub(:rollback_transaction)
-
-            ::ActiveRecord::Base.should_not_receive(:decrement_open_transactions)
-            Transaction.new.clean
-          end
-        end
-      end
-
-      describe "#connection_maintains_transaction_count?" do
-        it "should return true if the major active record version is < 4" do
-          stub_const("ActiveRecord::VERSION::MAJOR", 3)
-          Transaction.new.connection_maintains_transaction_count?.should be_true
-        end
-        it "should return false if the major active record version is > 3" do
-          stub_const("ActiveRecord::VERSION::MAJOR", 4)
-          Transaction.new.connection_maintains_transaction_count?.should be_false
-        end
-      end
-
-    end
-  end
-end

data/spec/database_cleaner/active_record/truncation/mysql2_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'support/active_record/mysql2_setup'
-require 'database_cleaner/active_record/truncation'
-require 'database_cleaner/active_record/truncation/shared_fast_truncation'
-
-module ActiveRecord
-  module ConnectionAdapters
-    describe do
-      before(:all) { active_record_mysql2_setup }
-
-      let(:connection) { active_record_mysql2_connection }
-
-      describe "#truncate_table" do
-        it "should truncate the table" do
-          2.times { User.create }
-
-          connection.truncate_table('users')
-          User.count.should eq 0
-        end
-
-        it "should reset AUTO_INCREMENT index of table" do
-          2.times { User.create }
-          User.delete_all
-
-          connection.truncate_table('users')
-
-          User.create.id.should eq 1
-        end
-      end
-
-      it_behaves_like "an adapter with pre-count truncation" do
-        let(:connection) { active_record_mysql2_connection }
-      end
-    end
-  end
-end
-

data/spec/database_cleaner/active_record/truncation/mysql_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'support/active_record/mysql_setup'
-require 'database_cleaner/active_record/truncation'
-require 'database_cleaner/active_record/truncation/shared_fast_truncation'
-
-module ActiveRecord
-  module ConnectionAdapters
-    describe do
-      before(:all) { active_record_mysql_setup }
-
-      let(:connection) { active_record_mysql_connection }
-
-      describe "#truncate_table" do
-        it "should truncate the table" do
-          2.times { User.create }
-
-          connection.truncate_table('users')
-          User.count.should eq 0
-        end
-
-        it "should reset AUTO_INCREMENT index of table" do
-          2.times { User.create }
-          User.delete_all
-
-          connection.truncate_table('users')
-
-          User.create.id.should eq 1
-        end
-      end
-
-      it_behaves_like "an adapter with pre-count truncation" do
-        let(:connection) { active_record_mysql_connection }
-      end
-    end
-  end
-end
-