saimonmoore-database_cleaner 0.5.0

data/lib/database_cleaner/mongo_mapper/truncation.rb

@@ -0,0 +1,30 @@
+require 'database_cleaner/truncation_base'
+
+module DatabaseCleaner
+  module MongoMapper
+    class Truncation < DatabaseCleaner::TruncationBase
+      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 connection
+        ::MongoMapper.connection
+      end
+
+      def collections
+        connection.db(database).collections
+      end
+
+      def database
+        ::MongoMapper.database.name
+      end
+    end
+  end
+end

data/lib/database_cleaner/truncation_base.rb

@@ -0,0 +1,41 @@
+module DatabaseCleaner
+  class TruncationBase
+
+    def initialize(options = {})
+      if !options.empty? && !(options.keys - [:only, :except]).empty?
+        raise ArgumentError, "The only valid options are :only and :except. You specified #{options.keys.join(',')}."
+      end
+      if options.has_key?(:only) && options.has_key?(:except)
+        raise ArgumentError, "You may only specify either :only or :either.  Doing both doesn't really make sense does it?"
+      end
+
+      @only = options[:only]
+      @tables_to_exclude = (options[:except] || [])
+      if migration_storage = migration_storage_name
+        @tables_to_exclude << migration_storage
+      end
+    end
+
+    def start
+      # no-op
+    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

data/spec/database_cleaner/active_record/truncation_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/active_record/truncation'
+require 'active_record'
+module ActiveRecord
+  module ConnectionAdapters
+    [MysqlAdapter, SQLite3Adapter, JdbcAdapter, PostgreSQLAdapter].each do |adapter|
+      describe adapter, "#truncate_table" do
+        it "should truncate the table"
+      end
+    end
+  end
+end
+
+module DatabaseCleaner
+  module ActiveRecord
+
+    describe Truncation do
+      before(:each) do
+        @connection = mock('connection')
+        @connection.stub!(:disable_referential_integrity).and_yield
+        ::ActiveRecord::Base.stub!(:connection).and_return(@connection)
+      end
+
+      it "should truncate all tables except for schema_migrations" do
+        @connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+        @connection.should_receive(:truncate_table).with('widgets')
+        @connection.should_receive(:truncate_table).with('dogs')
+        @connection.should_not_receive(:truncate_table).with('schema_migrations')
+
+        Truncation.new.clean
+      end
+
+      it "should only truncate the tables specified in the :only option when provided" do
+        @connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+        @connection.should_receive(:truncate_table).with('widgets')
+        @connection.should_not_receive(:truncate_table).with('dogs')
+
+        Truncation.new(:only => ['widgets']).clean
+      end
+
+      it "should not truncate the tables specified in the :except option" do
+        @connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
+
+        @connection.should_receive(:truncate_table).with('dogs')
+        @connection.should_not_receive(:truncate_table).with('widgets')
+
+        Truncation.new(:except => ['widgets']).clean
+      end
+
+      it "should raise an error when :only and :except options are used" do
+        running {
+          Truncation.new(:except => ['widgets'], :only => ['widgets'])
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error when invalid options are provided" do
+        running { Truncation.new(:foo => 'bar') }.should raise_error(ArgumentError)
+      end
+
+
+    end
+
+  end
+end

data/spec/database_cleaner/configuration_spec.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'database_cleaner/active_record/transaction'
+require 'database_cleaner/data_mapper/transaction'
+
+
+describe DatabaseCleaner do
+
+  # These examples muck around with the constants for autodetection so we need to clean up....
+  before(:all) do
+    TempAR = ActiveRecord unless defined?(TempAR)
+    TempMM = MongoMapper unless defined?(TempMM)
+    Object.send(:remove_const, 'MongoMapper') if defined?(::MongoMapper)
+    # need to add one for each ORM that we load in the spec helper...
+  end
+  after(:all) do
+    Object.send(:remove_const, 'ActiveRecord') if defined?(::ActiveRecord) #want to make sure we have the real one...
+    ActiveRecord = TempAR
+    MongoMapper = TempMM
+  end
+
+  before(:each) do
+    DatabaseCleaner::ActiveRecord::Transaction.stub!(:new).and_return(@strategy = mock('strategy'))
+    Object.const_set('ActiveRecord', "just mocking out the constant here...") unless defined?(::ActiveRecord)
+    DatabaseCleaner.strategy = nil
+    DatabaseCleaner.orm = nil
+  end
+
+  describe ".create_strategy" do
+    it "should initialize and return the appropirate strategy" do
+      DatabaseCleaner::ActiveRecord::Transaction.should_receive(:new).with('options' => 'hash')
+      result = DatabaseCleaner.create_strategy(:transaction, {'options' => 'hash'})
+      result.should == @strategy
+    end
+  end
+
+  describe ".clean_with" do
+    it "should initialize the appropirate strategy and clean with it" do
+      DatabaseCleaner::ActiveRecord::Transaction.should_receive(:new).with('options' => 'hash')
+      @strategy.should_receive(:clean)
+      DatabaseCleaner.clean_with(:transaction, 'options' => 'hash')
+    end
+  end
+
+  describe ".strategy=" do
+    it "should initialize the appropirate strategy based on the ORM adapter detected" do
+      DatabaseCleaner::ActiveRecord::Transaction.should_receive(:new).with('options' => 'hash')
+      DatabaseCleaner.strategy = :transaction, {'options' => 'hash'}
+
+      Object.send(:remove_const, 'ActiveRecord')
+      Object.const_set('DataMapper', "just mocking out the constant here...")
+      DatabaseCleaner.orm = nil
+
+      DatabaseCleaner::DataMapper::Transaction.should_receive(:new).with(no_args)
+      DatabaseCleaner.strategy = :transaction
+    end
+
+    it "should raise an error when no ORM is detected" do
+      Object.send(:remove_const, 'ActiveRecord') if defined?(::ActiveRecord)
+      Object.send(:remove_const, 'DataMapper') if defined?(::DataMapper)
+      Object.send(:remove_const, 'CouchPotato') if defined?(::CouchPotato)
+
+      running { DatabaseCleaner.strategy = :transaction }.should raise_error(DatabaseCleaner::NoORMDetected)
+    end
+
+    it "should use the strategy version of the ORM specified with #orm=" do
+      DatabaseCleaner.orm = 'data_mapper'
+      DatabaseCleaner::DataMapper::Transaction.should_receive(:new)
+
+      DatabaseCleaner.strategy = :transaction
+    end
+
+    it "should raise an error when multiple args is passed in and the first is not a symbol" do
+      running { DatabaseCleaner.strategy=Object.new, {:foo => 'bar'} }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error when the specified strategy is not found" do
+      running { DatabaseCleaner.strategy = :foo }.should raise_error(DatabaseCleaner::UnknownStrategySpecified)
+    end
+
+    it "should allow any object to be set as the strategy" do
+      mock_strategy = mock('strategy')
+      running { DatabaseCleaner.strategy = mock_strategy }.should_not raise_error
+    end
+
+  end
+
+
+    %w[start clean].each do |strategy_method|
+      describe ".#{strategy_method}" do
+        it "should be delgated to the strategy set with strategy=" do
+          DatabaseCleaner.strategy = :transaction
+
+          @strategy.should_receive(strategy_method)
+
+          DatabaseCleaner.send(strategy_method)
+        end
+
+        it "should raise en error when no strategy has been set" do
+          running { DatabaseCleaner.send(strategy_method) }.should raise_error(DatabaseCleaner::NoStrategySetError)
+        end
+      end
+    end
+
+end

data/spec/database_cleaner/couch_potato/truncation_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/couch_potato/truncation'
+require 'couch_potato'
+
+module DatabaseCleaner
+  module CouchPotato
+
+    describe Truncation do
+      before(:each) do
+        @database = mock('database')
+        ::CouchPotato.stub!(:couchrest_database).and_return(@database)
+      end
+
+      it "should re-create the database" do
+        @database.should_receive(:recreate!)
+
+        Truncation.new.clean
+      end
+
+      it "should raise an error when the :only option is used" do
+        running {
+          Truncation.new(:only => ['document-type'])
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error when the :except option is used" do
+        running {
+          Truncation.new(:except => ['document-type'])
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error when invalid options are provided" do
+        running {
+          Truncation.new(:foo => 'bar')
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+  end
+end

data/spec/database_cleaner/couchrest/truncation_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'database_cleaner/couchrest/truncation'
+require 'couchrest'
+
+  # DB_SERVER = CouchRest.new
+  # DB_SERVER.default_database = couchdb['database']  
+  # TEST_DB = DB_SERVER.database(DB_SERVER.default_database.name) unless defined? TEST_DB
+  #   TEST_DB.recreate!
+
+
+module DatabaseCleaner
+  module CouchRest
+    DEFAULT_DB_NAME= 'default_test_db'
+
+    describe Truncation do
+      before(:each) do
+        ::CouchRest.default_database_name = DEFAULT_DB_NAME
+
+        @database = mock('database')
+        ::CouchRest.stub!(:database!).and_return(@database)
+      end
+
+      it "it should raise an error if ::CouchRest.default_database_name has not been set" do
+        running {
+          ::CouchRest.default_database_name = nil
+          Truncation.new.clean()
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should re-create the database" do
+        @database.should_receive(:recreate!)
+
+        Truncation.new.clean()
+      end
+
+     it "should raise an error when the :only option is used" do
+        running {
+          Truncation.new(:only => ['document-type'])
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error when the :except option is used" do
+        running {
+          Truncation.new(:except => ['document-type'])
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error when invalid options are provided" do
+        running {
+          Truncation.new(:foo => 'bar')
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+  end
+end

data/spec/database_cleaner/mongo_mapper/truncation_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'mongomapper'
+require 'database_cleaner/mongo_mapper/truncation'
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
+TEST_DATABASE = 'database_cleaner_specs'
+MongoMapper.database = TEST_DATABASE
+
+class Widget
+  include MongoMapper::Document
+  key :name, String
+end
+class Gadget
+  include MongoMapper::Document
+  key :name, String
+end
+
+
+module DatabaseCleaner
+  module MongoMapper
+
+    describe Truncation do
+      before(:each) do
+        ::MongoMapper.connection.drop_database(TEST_DATABASE)
+        #::MongoMapper.connection.db(TEST_DATABASE).collections.each {|c| c.remove }
+        #::MongoMapper.database = TEST_DATABASE
+      end
+
+      def ensure_counts(expected_counts)
+        # I had to add this sanity_check garbage because I was getting non-determinisc results from mongomapper at times.. 
+        # very odd and disconcerting...
+        sanity_check = expected_counts.delete(:sanity_check)
+        begin
+          expected_counts.each do |model_class, expected_count|
+            model_class.count.should equal(expected_count), "#{model_class} expected to have a count of #{expected_count} but was #{model_class.count}"
+          end
+        rescue Spec::Expectations::ExpectationNotMetError => e
+          raise !sanity_check ? e : Spec::ExpectationNotMetError::ExpectationNotMetError.new("SANITY CHECK FAILURE! This should never happen here: #{e.message}")
+        end
+      end
+
+      def create_widget(attrs={})
+        Widget.new({:name => 'some widget'}.merge(attrs)).save!
+      end
+
+      def create_gadget(attrs={})
+        Gadget.new({:name => 'some gadget'}.merge(attrs)).save!
+      end
+
+      it "truncates all collections by default" do
+        create_widget
+        create_gadget
+        ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
+        Truncation.new.clean
+        ensure_counts(Widget => 0, Gadget => 0)
+      end
+
+      context "when collections are provided to the :only option" do
+        it "only truncates the specified collections" do
+          create_widget
+          create_gadget
+          ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
+          Truncation.new(:only => ['widgets']).clean
+          ensure_counts(Widget => 0, Gadget => 1)
+        end
+      end
+
+      context "when collections are provided to the :except option" do
+        it "truncates all but the specified collections" do
+          create_widget
+          create_gadget
+          ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
+          Truncation.new(:except => ['widgets']).clean
+          ensure_counts(Widget => 1, Gadget => 0)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format nested
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'spec'
+require 'activerecord'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'database_cleaner'
+
+Spec::Runner.configure do |config|
+  
+end
+
+alias running lambda