dsturnbull-database_cleaner 0.2.4

data/History.txt

@@ -0,0 +1,41 @@
+0.2.x (In Git)
+
+== 0.2.3 2009-05-30
+
+ === New features
+  * Support for SQL Server truncation (Adam Meehan)
+
+== 0.2.2 2009-05-08
+ === Bufixes
+  * Added proper gemspec description and summary. (Ben Mabey, thanks to Martin Gamsjaeger)
+
+ === New features
+
+== 0.2.1 2009-05-08
+ === Bufixes
+  * Removed extraneous TruncationBase class definition. (Ben Mabey)
+
+== 0.2.0 2009-05-08 - The Datamapper Release
+
+ === New features
+  * DataMapper strategies (Martin Gamsjaeger)
+    * Transaction
+    * Truncation - working SQLite3, MySQL adapters. Experimental Postgres adapter (not tested).
+
+== 0.1.3 2009-04-30
+
+ === New features 
+  * PostgresSQLAdapter for AR to support the truncation strategy. (Alberto Perdomo)
+ === Bufixes
+  * Added missing quotes around table names in truncation calls. (Michael MacDonald)
+
+== 0.1.2 2009-03-05
+ === New features
+  * JDBC Adapter to enable AR truncation strategy to work. (Kamal Fariz Mahyuddin)
+
+== 0.1.1 2009-03-04 - Initial Release (Ben Mabey)
+  * Basic infrastructure
+  * Features, RSpec code examples
+  * ActiveRecord strategies
+    * Truncation - with MySQL, and SQLite3 adapters.
+    * Transaction - wrap your modifications and roll them back.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ben Mabey
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,118 @@
+h1. Database Cleaner
+
+Database Cleaner is a set of strategies for cleaning your database in Ruby.
+The original use case was to ensure a clean state during tests.  Each strategy
+is a small amount of code but is code that is usually needed in any ruby app
+that is testing with a database.
+
+Both ActiveRecord and DataMapper are supported.
+
+h2. How to use
+
+<pre>
+  require 'database_cleaner'
+  DatabaseCleaner.strategy = :truncation
+
+  # then, whenever you need to clean the DB
+  DatabaseCleaner.clean
+</pre>
+
+With the :truncation strategy you can also pass in options, for example:
+<pre>
+  DatabaseCleaner.strategy = :truncation, {:only => %w[widgets dogs some_other_table]}
+</pre>
+
+<pre>
+  DatabaseCleaner.strategy = :truncation, {:except => %w[widgets]}
+</pre>
+
+(I should point out the truncation strategy will never truncate your schema_migrations table.)
+
+
+Some strategies require that you call DatabaseCleaner.start before calling clean
+(for example the :transaction one needs to know to open up a transaction). So
+you would have:
+
+<pre>
+  require 'database_cleaner'
+  DatabaseCleaner.strategy = :transaction
+
+  DatabaseCleaner.start # usually this is called in setup of a test
+  dirty_the_db
+  DatabaseCleaner.clean # cleanup of the test
+</pre>
+
+At times you may want to do a single clean with one strategy.  For example, you may want
+to start the process by truncating all the tables, but then use the faster transaction
+strategy the remaining time.  To accomplish this you can say:
+
+<pre>
+  require 'database_cleaner'
+  DatabaseCleaner.clean_with :truncation
+  DatabaseCleaner.strategy = :transaction
+  # then make the DatabaseCleaner.start and DatabaseCleaner.clean calls appropriately
+</pre>
+
+Example usage with RSpec:
+
+<pre>
+Spec::Runner.configure do |config|
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+end
+</pre>
+
+For use in Cucumber please see the section below.
+
+
+
+h2. Why?
+
+One of my motivations for writing this library was to have an easy way to
+turn on what Rails calls "transactional_fixtures" in my non-rails
+ActiveRecord projects.  For example, Cucumber ships with a Rails world that
+will wrap each scenario in a transaction.  This is great, but what if you are
+using ActiveRecord in a non-rails project?  You used to have to copy-and-paste
+the needed code, but with DatabaseCleaner you can now say:
+
+<pre>
+  #env.rb
+  require 'database_cleaner'
+  require 'database_cleaner/cucumber'
+  DatabaseCleaner.strategy = :transaction
+</pre>
+
+Now lets say you are running your features and it requires that another process be
+involved (i.e. Selenium running against your app's server.)  You can simply change
+your strategy type:
+
+<pre>
+  #env.rb
+  require 'database_cleaner'
+  require 'database_cleaner/cucumber'
+  DatabaseCleaner.strategy = :truncation
+</pre>
+
+You can have the best of both worlds and use the best one for the job:
+<pre>
+  #env.rb
+  require 'database_cleaner'
+  require 'database_cleaner/cucumber'
+  DatabaseCleaner.strategy = (ENV['SELENIUM'] == 'true') ? :truncation : :transaction
+</pre>
+
+h2. COPYRIGHT
+
+Copyright (c) 2009 Ben Mabey. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "database_cleaner"
+    s.summary = %Q{Strategies for cleaning databases.  Can be used to ensure a clean state for testing.}
+    s.email = "ben@benmabey.com"
+    s.homepage = "http://github.com/bmabey/database_cleaner"
+    s.description = "Strategies for cleaning databases.  Can be used to ensure a clean state for testing."
+    s.files = FileList["[A-Z]*.*", "{examples,lib,features,spec}/**/*", "Rakefile", "cucumber.yml"]
+    s.authors = ["Ben Mabey"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'database_cleaner'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+end
+
+task :default => [:spec, :features]

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 2
+:major: 0
+:minor: 2

data/cucumber.yml

@@ -0,0 +1 @@
+default: features

data/examples/features/example.feature

@@ -0,0 +1,11 @@
+Feature: example
+ In order to test DataBase Cleaner
+ Here are some scenarios that rely on the DB being clean!
+
+  Scenario: dirty the db
+    When I create a widget
+    Then I should see 1 widget
+
+  Scenario: assume a clean db
+    When I create a widget
+    Then I should see 1 widget

data/examples/features/step_definitions/example_steps.rb

@@ -0,0 +1,8 @@
+When /^I create a widget$/ do
+  Widget.create!
+end
+
+Then /^I should see 1 widget$/ do
+  Widget.count.should == 1
+end
+

data/examples/features/support/env.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'spec/expectations'
+
+orm      = ENV['ORM']
+strategy = ENV['STRATEGY']
+
+if orm && strategy
+  
+  begin
+    require "#{File.dirname(__FILE__)}/../../lib/#{orm}"
+  rescue LoadError
+    raise "You don't have the #{orm} ORM installed"
+  end
+
+  $:.unshift(File.dirname(__FILE__) + '/../../../lib')
+  require 'database_cleaner'
+  require 'database_cleaner/cucumber'
+
+  DatabaseCleaner.strategy = strategy.to_sym
+  
+else
+  raise "Run 'ORM=activerecord|datamapper STRATEGY=transaction|truncation cucumber examples/features'"
+end

data/examples/lib/activerecord.rb

@@ -0,0 +1,12 @@
+require 'activerecord'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :widgets do |t|
+    t.string :name
+  end
+end
+
+class Widget < ActiveRecord::Base
+end

data/examples/lib/datamapper.rb

@@ -0,0 +1,16 @@
+require "dm-core"
+
+# only to please activerecord API used in database_cleaner/examples/features/step_definitions
+# yes, i know that's lazy ...
+require "dm-validations"
+require "dm-aggregates"
+
+DataMapper.setup(:default, "sqlite3::memory:")
+
+class Widget
+  include DataMapper::Resource
+  property :id,   Serial
+  property :name, String
+end
+
+Widget.auto_migrate!

data/features/cleaning.feature

@@ -0,0 +1,18 @@
+Feature: database cleaning
+  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 <ORM>
+    And the <Strategy> cleaning strategy
+
+    When I run my scenarios that rely on a clean database
+    Then I should see all green
+
+  Examples:
+    | ORM          | Strategy      |
+    | ActiveRecord | transaction   |
+    | ActiveRecord | truncation    |
+    | DataMapper   | transaction   |
+    | DataMapper   | truncation    |

data/features/step_definitions/database_cleaner_steps.rb

@@ -0,0 +1,25 @@
+Given /^I am using (ActiveRecord|DataMapper)$/ 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 = `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,69 @@
+require "database_cleaner/truncation_base"
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    class MysqlAdapter < AbstractAdapter
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+    end
+
+    class SQLite3Adapter < AbstractAdapter
+      def truncate_table(table_name)
+        execute("DELETE FROM #{quote_table_name(table_name)};")
+      end
+    end
+
+    class JdbcAdapter < AbstractAdapter
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+    end
+
+    class PostgreSQLAdapter < AbstractAdapter
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+    end
+
+    class SQLServerAdapter < 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,94 @@
+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
+
+  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
+
+    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
+
+    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? ::ActiveRecord
+          'active_record'
+        elsif defined? ::DataMapper
+          'data_mapper'
+        else
+          raise NoORMDetected, "No known ORM was detected!  Is ActiveRecord or DataMapper loaded?"
+        end
+      end
+    end
+
+
+    def orm_module
+      case orm
+      when 'active_record'
+        DatabaseCleaner::ActiveRecord
+      when 'data_mapper'
+        DatabaseCleaner::DataMapper
+      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)
+        query 'SHOW TABLES'
+      end
+
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+
+      # copied from activerecord
+      def disable_referential_integrity
+        old = query("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.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
+        query sql
+      end
+
+      def truncate_table(table_name)
+        execute("DELETE FROM #{quote_table_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
+        query(sql)
+      end
+
+      def truncate_table(table_name)
+        execute("TRUNCATE TABLE #{quote_table_name(table_name)};")
+      end
+
+      # FIXME
+      # copied from activerecord
+      def supports_disable_referential_integrity?
+        version = query("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_table_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_table_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

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,101 @@
+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)
+    # 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
+  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)
+
+      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/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

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: dsturnbull-database_cleaner
+version: !ruby/object:Gem::Version 
+  version: 0.2.4
+platform: ruby
+authors: 
+- Ben Mabey
+- David Turnbull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-01 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: Strategies for cleaning databases.  Can be used to ensure a clean state for testing.
+email: dsturnbull@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- History.txt
+- README.textile
+- Rakefile
+- VERSION.yml
+- cucumber.yml
+- examples/features/example.feature
+- examples/features/step_definitions/example_steps.rb
+- examples/features/support/env.rb
+- examples/lib/activerecord.rb
+- examples/lib/datamapper.rb
+- features/cleaning.feature
+- features/step_definitions/database_cleaner_steps.rb
+- features/support/env.rb
+- lib/database_cleaner.rb
+- lib/database_cleaner/active_record/transaction.rb
+- lib/database_cleaner/active_record/truncation.rb
+- lib/database_cleaner/configuration.rb
+- lib/database_cleaner/cucumber.rb
+- lib/database_cleaner/data_mapper/transaction.rb
+- lib/database_cleaner/data_mapper/truncation.rb
+- lib/database_cleaner/truncation_base.rb
+- spec/database_cleaner/active_record/truncation_spec.rb
+- spec/database_cleaner/configuration_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/dsturnbull/database_cleaner
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Strategies for cleaning databases.  Can be used to ensure a clean state for testing.
+test_files: 
+- spec/spec_helper.rb
+- spec/database_cleaner/configuration_spec.rb
+- spec/database_cleaner/active_record/truncation_spec.rb
+- examples/lib/datamapper.rb
+- examples/lib/activerecord.rb
+- examples/features/step_definitions/example_steps.rb
+- examples/features/support/env.rb