pseudo_cleaner 0.0.25

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    N2YxYjQzYTAzZDJkN2M0YzQ0YjE1ODgwMjA3Y2ZlYWNiNTQzNTk4NQ==
+  data.tar.gz: !binary |-
+    ZGI3ODU3NGEyOTE5NGUxODBhNjhlMjk2MTM3ODA5OGZjZDA3NzU4ZQ==
+SHA512:
+  metadata.gz: !binary |-
+    MDUxNTk3ZDNiM2RlZDJmYzM5NGRlZjhhMzQ5Yjg1YWY4OTE2MmQ5ZWY1ZWVj
+    MTM2MGM0MzQ3MTNkYWIxNDQyYjUxZGQ1OTVkYTg5YjJmNTQ1ZTk2MmExNmNj
+    YzY1MWE5ZjdkMWY3YmMxNjQ1ODgxYmQxNzQ0ZGM4OWIyYzMzZmM=
+  data.tar.gz: !binary |-
+    NzBlNGYwNmU4ZTA0MDM4MzA3YTRjYjI4NzY4YTJlZTk1YjJhMTM2ZjA3YjUw
+    MjlmMDUyNzZlNzI2NmE4ZGUyNDQ5ODBlNjM5NDEyNGQwMzMwYzc2ODk1Zjk5
+    NjRhY2VhNTdlM2RmNWNmYjQ2MGZhOGI1NmIyY2EwMWVlMmMwMmM=

data/.gitignore

@@ -0,0 +1,18 @@
+.idea/
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pseudo_cleaner.gemspec
+gemspec
+
+gem "gem-release"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 RealNobody
+
+MIT License
+
+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.md

@@ -0,0 +1,142 @@
+# PseudoCleaner
+
+The [Database Cleaner gem](https://github.com/DatabaseCleaner/database_cleaner) is a wonderful tool,
+and I've used it for years.  I would highly recommend it.  It is a well written and a well used and therefore tested
+tool that you can rely on.
+
+However, it is (quite rightly) a very conservative tool.  I often run into situations where it doesn't quite fit my
+needs.  there are often times when I cannot use transactions (such as when I am doing Cucumber tests with Capybara to
+feature test my site), but when truncating my tables just isn't reasonable or practical.
+
+So, I came up with a compromise that works for a large number of tables and databases that I've worked with.  The
+thing is that this solution is not like DatabaseCleaner in that it isn't conservative,
+and it doesn't guarantee much.  This solution might not clean the database entirely between calls.
+
+The thing is, the database doesn't have to be entirely clean after every call for most tests,
+just clean enough is often good enough.
+
+So, what is it that the PseudoCleaner does and why is it good enough?
+
+The cleaner relies on the fact that most databases use 2 common defaults in most tables (well,
+most tables that simple tests that rely on the workings of a cleaner anyway...)  Those features are an auto-increment
+`id` column, and/or a `created_at`/`updated_at` columns.
+
+Using these, when a test starts the cleaner iterates through the tables and saves the current `MAX(id)`,
+`MAX(created_at)`, and `MAX(updated_at)` values for a table.  When a test ends, the cleaner iterates through the
+tables again and deletes anything that is new.  It will then report (optionally) on any records that have been
+updated but haven't been cleaned up.  In future versions, I have plans for it to also report (optionally) on any
+referential integrity holes.
+
+Because the PsuedoCleaner already uses the [SortedSeeder gem](https://github.com/RealNobody/sorted_seeder) to determine what
+order to delete records in when cleaning up, when the database is truncated, it will re-seed the database using the
+SortedSeeders seed_all function.
+
+## Installation
+
+Add this line to your application's Gemfile in the test group:
+
+    gem 'pseudo_cleaner'
+
+OR
+
+    gem 'pseudo_cleaner', '~> 0.0.1', :git => "git@github.com/RealNobody/pseudo_cleaner.git"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pseudo_cleaner
+
+## Usage
+
+There are multiple ways to use the PseudoCleaner.  The main intended usages are detailed here:
+
+### Rspec
+
+Rspect integration is built in to make using the PseudoCleaner simple and straight-forward.
+To integrate the PseudoCleaner with Rspec, simply add the following lines to `spec_helper.rb`:
+
+    require 'pseudo_cleaner'
+    require 'pseudo_cleaner/rspec'
+
+All tests will now by default use DatabaseCleaner with the `:transaction` strategy.  For most tests, this will wrap
+the test in a transaction, and roll back the transaction at the end of the test.
+
+If a test is a feature test which uses Capybara using the `:js` tag, that test will be switched to not use
+DatabaseCleaner.  Instead, the test will use the `:pseudo_delete` strategy which as described will store the state of
+the tables before the test then delete any new records at the end of the test.
+
+If you want or need a specific strategy for a single test, you can specify the metadata tag: `:strategy` in the test
+to change the behavior of the test.  This tag accepts the following values:
+
+* :none - Do not use any cleaning on this test run.
+* :psedu_delete - Do not use DatabaseCleaner and clean tables individually.
+* :truncation - Use the :truncation strategy with DatabaseCleaner and re-seed the database after truncation.
+* :deletion - Use the :deletion strategy with DatabaseCleaner and re-seed the database after deletion.
+* :transaction - Use the :transaction strategy with DatabaseCleaner.
+
+Example:
+
+    it "is a test", strategy: :truncation do
+      expect(something).to work
+    end
+
+### Cucumber
+
+Cucumber integration similar to Rspec integration is planned, but not implemented yet.
+
+### Manual
+
+There are two ways to use the cleaner manually.  When you use the cleaner manually, you are only using the
+PseduoCleaner.  You do not get DatabaseCleaner integration like you get automatically with Rspec.  This will create
+table cleaners and any custom defined cleaners and execute them.
+
+NOTE:  When using the tool manually, if the strategy is any strategy other than `:pseudo_delete`, the default
+cleaners will not do anything.  The strategy may still be useful though if you have any custom cleaners.
+
+*PseudoCleaner::MasterCleaner.clean*  This function cleans the code executed inside a block and takes two parameters.
+The first parameter takes the values `:test` or `:suite`.  This is used to determine if the cleaner is wrapped around
+a set of tests or a single test. The default implementations provided do not distinguish between these, but custom
+cleaners might.  The second parameter is the strategy to use.
+
+    PseudoCleaner::MasterCleaner.clean(:test, :pseudo_delete) do
+      # Your code here
+    end
+
+*PseudoCleaner::MasterCleaner.start_test*  This takes one parameter that is the type of the cleaner this is (`:test` or
+`:suite`).  This creates a cleaner object that can be started and ended around the code to be cleaned.  You specify
+the strategy for the tests when you start the cleaner.
+
+    pseudo_cleaner = PseudoCleaner::MasterCleaner.start_test :pseudo_delete
+    # Your code here
+    pseudo_cleaner.end
+
+## Custom Cleaners
+
+This system is built to clean the database after calls.
+
+If you have additional actions which need to be done either before and/or after tests run to clean up resources, you
+can create custom cleaners and place them in the `db/cleaners` folder.  You can also create a custom cleaner for a
+specific table by placing the cleaner in the same folder and naming it `<TableName>Cleaner`.
+
+Cleaners must be instantiated, and will be initialized with the following prototype:
+`initialize(start_method, end_method, table, options = {})`
+
+Cleaners must also include one or more of the following funcitons:
+
+* test_start test_strategy
+* test_end test_strategy
+* suite_start test_strategy
+* suite_end test_strategy
+
+A Cleaner can adjust when it is called in relation to other cleaners by overriding the instance method `<=>`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/pseudo_cleaner.rb

@@ -0,0 +1,12 @@
+require "sorted_seeder"
+require "colorize"
+require "database_cleaner"
+require "pseudo_cleaner/version"
+require "pseudo_cleaner/configuration"
+require "pseudo_cleaner/table_cleaner"
+require "pseudo_cleaner/master_cleaner"
+require "pseudo_cleaner/logger"
+
+module PseudoCleaner
+  # Your code goes here...
+end

data/lib/pseudo_cleaner/configuration.rb

@@ -0,0 +1,44 @@
+module PseudoCleaner
+  class Configuration
+    @@current_instance = nil
+
+    # A simple configuration class for the PseudoCleaner
+    #
+    # Configurations:
+    #   output_diagnostics  - true/false
+    #                         if true, the system will use puts to output information about what it is doing...
+    attr_accessor :output_diagnostics
+    attr_accessor :clean_database_before_tests
+    attr_accessor :reset_auto_increment
+    attr_accessor :single_cleaner_set
+    attr_accessor :post_transaction_analysis
+
+    def self.current_instance
+      @@current_instance ||= PseudoCleaner::Configuration.new
+    end
+
+    def initialize
+      @output_diagnostics = false           # false to keep the noise level down...
+      @clean_database_before_tests = false  # false because I think it will annoy developers...
+      @reset_auto_increment = true          # true because I think it should be done
+      @single_cleaner_set = true            # true because I hope it will improve performance
+      @post_transaction_analysis = false    # should only be set true if you are searching for a problem
+    end
+
+    def self.db_connection=(connection)
+      @db_connection = connection
+    end
+
+    def self.db_connection(type)
+      if @db_connection || type.nil?
+        @db_connection
+      else
+        if type == :sequel
+          Sequel::DATABASES[0]
+        else
+          ActiveRecord::Base
+        end
+      end
+    end
+  end
+end

data/lib/pseudo_cleaner/cucumber.rb

@@ -0,0 +1,44 @@
+first_test_run                                     = false
+
+# turn off Cucumber's default usage of DatabaseCleaner
+Cucumber::Rails::Database.autorun_database_cleaner = false
+
+Before do |scenario|
+  unless first_test_run
+    first_test_run = true
+    # before tests run...
+    # We start suite in case a custom cleaner wants/needs to.
+    if PseudoCleaner::Configuration.current_instance.clean_database_before_tests
+      PseudoCleaner::MasterCleaner.reset_database
+    else
+      PseudoCleaner::MasterCleaner.start_suite
+    end
+
+    DatabaseCleaner.strategy = :transaction
+  end
+end
+
+Before("~@truncation", "~@deletion") do |scenario|
+  PseudoCleaner::MasterCleaner.start_example(scenario, :pseudo_delete)
+end
+
+Before("@truncation") do |scenario|
+  PseudoCleaner::MasterCleaner.start_example(scenario, :truncation)
+end
+
+Before("@deletion", "~@truncation") do |scenario|
+  PseudoCleaner::MasterCleaner.start_example(scenario, :deletion)
+end
+
+Before("@none") do |scenario|
+  PseudoCleaner::MasterCleaner.start_example(scenario, :none)
+end
+
+After do |scenario|
+  PseudoCleaner::MasterCleaner.end_example(scenario)
+end
+
+at_exit do
+  # We end suite in case a custom cleaner wants/needs to.
+  PseudoCleaner::MasterCleaner.end_suite
+end

data/lib/pseudo_cleaner/logger.rb

@@ -0,0 +1,9 @@
+module PseudoCleaner
+  class Logger
+    class << self
+      def write(log_output)
+        puts(log_output)
+      end
+    end
+  end
+end

data/lib/pseudo_cleaner/master_cleaner.rb

@@ -0,0 +1,380 @@
+require "sorted_seeder"
+
+module PseudoCleaner
+  class MasterCleaner
+    @@suite_cleaner          = nil
+    @@cleaner_classes        = nil
+    @@cleaner_classes_sorted = false
+
+    CLEANING_STRATEGIES            = [:transaction, :truncation, :deletion, :pseudo_delete, :none]
+    DB_CLEANER_CLEANING_STRATEGIES =
+        {
+            transaction:   :transaction,
+            truncation:    :truncation,
+            deletion:      :deletion,
+            pseudo_delete: :transaction
+        }
+    VALID_TEST_TYPES               = [:suite, :test]
+
+    VALID_START_METHODS = [:test_start, :suite_start]
+    VALID_END_METHODS   = [:test_end, :suite_end]
+    VALID_TEST_METHODS  = VALID_START_METHODS + VALID_END_METHODS
+
+    class << self
+      def start_suite
+        if @@suite_cleaner
+          @@suite_cleaner.reset_suite
+        end
+        @@suite_cleaner = PseudoCleaner::MasterCleaner.new(:suite)
+        @@suite_cleaner.start :pseudo_delete
+        @@suite_cleaner
+      end
+
+      def start_example(example_class, strategy)
+        pseudo_cleaner_data                 = {}
+        pseudo_cleaner_data[:test_strategy] = strategy
+
+        unless strategy == :none
+          raise "invalid strategy" unless PseudoCleaner::MasterCleaner::DB_CLEANER_CLEANING_STRATEGIES.has_key? strategy
+
+          DatabaseCleaner.strategy = PseudoCleaner::MasterCleaner::DB_CLEANER_CLEANING_STRATEGIES[strategy]
+          unless [:pseudo_delete].include? strategy
+            if Object.const_defined?("ActiveRecord", false) && ActiveRecord.const_defined?("Base", false)
+              DatabaseCleaner[:active_record, connection: PseudoCleaner::Configuration.db_connection(:active_record)].
+                  start
+            elsif Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+              DatabaseCleaner[:sequel, connection: PseudoCleaner::Configuration.db_connection(:sequel)].start
+            end
+            # DatabaseCleaner.start
+          end
+
+          pseudo_cleaner_data[:pseudo_state] = PseudoCleaner::MasterCleaner.start_test strategy
+        end
+
+        example_class.instance_variable_set(:@pseudo_cleaner_data, pseudo_cleaner_data)
+      end
+
+      def end_example(example_class)
+        pseudo_cleaner_data = example_class.instance_variable_get(:@pseudo_cleaner_data)
+
+        unless pseudo_cleaner_data[:test_strategy] == :none
+          unless [:pseudo_delete].include? pseudo_cleaner_data[:test_strategy]
+            if Object.const_defined?("ActiveRecord", false) && ActiveRecord.const_defined?("Base", false)
+              DatabaseCleaner[:active_record, connection: PseudoCleaner::Configuration.db_connection(:active_record)].
+                  clean
+            elsif Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+              DatabaseCleaner[:sequel, connection: PseudoCleaner::Configuration.db_connection(:sequel)].clean
+            end
+            # DatabaseCleaner.clean
+          end
+
+          case pseudo_cleaner_data[:test_strategy]
+            when :deletion, :truncation
+              PseudoCleaner::MasterCleaner.database_reset
+          end
+
+          pseudo_cleaner_data[:pseudo_state].end test_type: :test, test_strategy: pseudo_cleaner_data[:test_strategy]
+        end
+      end
+
+      def end_suite
+        @@suite_cleaner.end test_strategy: :pseudo_delete if @@suite_cleaner
+      end
+
+      def start_test test_strategy
+        raise "Invalid test_strategy \"#{test_strategy}\"" unless CLEANING_STRATEGIES.include? test_strategy
+
+        cleaner = if PseudoCleaner::Configuration.current_instance.single_cleaner_set
+                    @@suite_cleaner
+                  else
+                    PseudoCleaner::MasterCleaner.new(:test)
+                  end
+
+        cleaner.start test_strategy, test_type: :test, test_strategy: test_strategy
+
+        cleaner
+      end
+
+      def clean(test_type, test_strategy, &block)
+        raise "Invalid test_type \"#{test_type}\"" unless [:suite, :test].include? test_type
+        raise "Invalid test_strategy \"#{test_strategy}\"" unless CLEANING_STRATEGIES.include? test_strategy
+
+        master_cleaner = PseudoCleaner::MasterCleaner.send "start_#{test_type}", test_strategy
+
+        body_error = nil
+        begin
+          block.yield master_cleaner
+        rescue => error
+          body_error = error
+        end
+
+        master_cleaner.end test_type: test_type, test_strategy: test_strategy
+
+        raise body_error if body_error
+      end
+
+      def reset_database
+        DatabaseCleaner.clean_with(:truncation)
+
+        PseudoCleaner::MasterCleaner.database_reset
+      end
+
+      def database_reset
+        PseudoCleaner::MasterCleaner.seed_data
+        PseudoCleaner::MasterCleaner.start_suite
+      end
+
+      def seed_data
+        PseudoCleaner::Logger.write("Re-seeding database".red.on_light_white)
+        SortedSeeder::Seeder.seed_all(PseudoCleaner::Configuration.db_connection(nil))
+      end
+
+      def process_exception(error)
+        PseudoCleaner::Logger.write("    An exception has occurred:".red.on_light_white)
+        PseudoCleaner::Logger.write("")
+        PseudoCleaner::Logger.write(error.to_s)
+        PseudoCleaner::Logger.write(error.backtrace.join("\n")) if error.backtrace
+      end
+
+      def cleaner_class(table_name)
+        seed_class_name      = "#{table_name.to_s.classify}Cleaner"
+        seed_class_base_name = seed_class_name.demodulize
+        base_module          = seed_class_name.split("::")[0..-2].join("::")
+        base_module_classes  = [Object]
+
+        unless base_module.blank?
+          base_module_classes = base_module_classes.unshift base_module.constantize
+        end
+
+        return_class = nil
+        2.times do
+          base_module_classes.each do |base_class|
+            if (base_class.const_defined?(seed_class_base_name, false))
+              if base_class == Object
+                return_class = seed_class_base_name.constantize
+              else
+                return_class = "#{base_class.name}::#{seed_class_base_name}".constantize
+              end
+
+              break
+            end
+          end
+
+          break if return_class
+
+          seeder_file = "db/cleaners/"
+          seeder_file += base_module.split("::").map { |module_name| module_name.underscore }.join("/")
+          seeder_file += "/" unless seeder_file[-1] == "/"
+          seeder_file += seed_class_base_name.underscore
+          seeder_file += ".rb"
+          seeder_file = File.join(Rails.root, seeder_file)
+
+          break unless File.exists?(seeder_file)
+
+          require seeder_file
+        end
+
+        # unless return_class &&
+        #     VALID_TEST_METHODS.any? { |test_method| return_class.instance_methods.include?(test_method.to_sym) }
+        #   return_class = table
+        # end
+
+        unless return_class &&
+            VALID_TEST_METHODS.any? { |test_method| return_class.instance_methods.include?(test_method.to_sym) }
+          return_class = PseudoCleaner::TableCleaner
+        end
+
+        return_class
+      end
+
+      def cleaner_classes
+        unless @@cleaner_classes
+          @@cleaner_classes = []
+
+          PseudoCleaner::MasterCleaner.create_table_cleaners
+          PseudoCleaner::MasterCleaner.create_custom_cleaners
+        end
+
+        @@cleaner_classes
+      end
+
+      def create_table_cleaners(options = {})
+        SortedSeeder::Seeder.create_order(PseudoCleaner::Configuration.db_connection(nil)).each do |table|
+          cleaner_class = PseudoCleaner::MasterCleaner.cleaner_class(table.name)
+          if cleaner_class
+            PseudoCleaner::MasterCleaner.cleaner_classes << [table, nil, cleaner_class]
+          end
+        end
+        if SortedSeeder::Seeder.respond_to?(:unclassed_tables)
+          SortedSeeder::Seeder.unclassed_tables(PseudoCleaner::Configuration.db_connection(nil)).each do |table_name|
+            cleaner_class = PseudoCleaner::MasterCleaner.cleaner_class(table_name)
+            if cleaner_class
+              PseudoCleaner::MasterCleaner.cleaner_classes << [nil, table_name, cleaner_class]
+            end
+          end
+        end
+      end
+
+      def create_custom_cleaners(options = {})
+        if Object.const_defined?("Rails", false)
+          cleaner_root  = Rails.root.join("db/cleaners/").to_s
+          cleaner_files = Dir[Rails.root.join("db/cleaners/**/*.rb")]
+
+          cleaner_files.each do |cleaner_file|
+            class_name = File.basename(cleaner_file, ".rb").classify
+
+            check_class, full_module_name = find_file_class(cleaner_file, cleaner_root)
+            unless check_class && check_class.const_defined?(class_name, false)
+              require cleaner_file
+              check_class, full_module_name = find_file_class(cleaner_file, cleaner_root)
+            end
+
+            if check_class
+              full_module_name << class_name
+              if check_class.const_defined?(class_name, false)
+                check_class = full_module_name.join("::").constantize
+              else
+                check_class = nil
+              end
+            end
+
+            if check_class &&
+                PseudoCleaner::MasterCleaner::VALID_TEST_METHODS.
+                    any? { |test_method| check_class.instance_methods.include?(test_method) }
+              unless PseudoCleaner::MasterCleaner.cleaner_classes.any? { |cleaner| check_class == cleaner[2] }
+                PseudoCleaner::MasterCleaner.cleaner_classes << [nil, nil, check_class]
+              end
+            end
+          end
+        end
+      end
+
+      def find_file_class(seeder_file, seeder_root)
+        check_class      = Object
+        full_module_name = []
+
+        File.dirname(seeder_file.to_s[seeder_root.length..-1]).split("/").map do |module_element|
+          if (module_element != ".")
+            full_module_name << module_element.classify
+            if check_class.const_defined?(full_module_name[-1], false)
+              check_class = full_module_name.join("::").constantize
+            else
+              check_class = nil
+              break
+            end
+          end
+        end
+
+        return check_class, full_module_name
+      end
+
+      def review_rows(&block)
+        @@suite_cleaner.review_rows &block
+      end
+    end
+
+    def initialize(test_type)
+      raise "Invalid test type.  Must be one of: #{VALID_TEST_TYPES}" unless VALID_TEST_TYPES.include?(test_type)
+
+      @test_type = test_type
+    end
+
+    def start(test_strategy, options = {})
+      test_type = options[:test_type] || @test_type
+
+      unless @cleaners
+        @cleaners      = []
+        @test_strategy = test_strategy
+
+        start_method = "#{test_type}_start".to_sym
+        end_method   = "#{test_type}_end".to_sym
+
+        PseudoCleaner::MasterCleaner.cleaner_classes.each do |clean_class|
+          table = clean_class[0]
+          table ||= clean_class[1]
+
+          begin
+            @cleaners << clean_class[2].new(start_method, end_method, table, options)
+          rescue Exception => error
+            puts error.to_s
+            raise error
+          end
+        end
+
+        unless @@cleaner_classes_sorted
+          seed_sorts = @cleaners.map { |cleaner| SortedSeeder::Seeder::SeederSorter.new(cleaner) }
+          seed_sorts.sort!
+
+          @cleaners = seed_sorts.map(&:seed_base_object)
+
+          sorted_classes = []
+          @cleaners.each do |cleaner|
+            cleaner_class = PseudoCleaner::MasterCleaner.cleaner_classes.detect do |unsorted_cleaner|
+              if cleaner.class == unsorted_cleaner[2]
+                if unsorted_cleaner[2] == PseudoCleaner::TableCleaner
+                  cleaner.table == unsorted_cleaner[0] || cleaner.table == unsorted_cleaner[1]
+                else
+                  true
+                end
+              end
+            end
+
+            sorted_classes << cleaner_class
+          end
+
+          @@cleaner_classes        = sorted_classes
+          @@cleaner_classes_sorted = true
+        end
+      end
+
+      start_all_cleaners options
+    end
+
+    def end(options = {})
+      test_type = options[:test_type] || @test_type
+      if PseudoCleaner::Configuration.current_instance.output_diagnostics ||
+          PseudoCleaner::Configuration.current_instance.post_transaction_analysis
+        PseudoCleaner::Logger.write("Cleaning #{test_type}")
+      end
+      end_all_cleaners options
+    end
+
+    def start_all_cleaners(options)
+      test_type     = options[:test_type] || @test_type
+      test_strategy = options[:test_strategy] || @test_strategy
+      run_all_cleaners("#{test_type}_start".to_sym, @cleaners, test_strategy)
+    end
+
+    def end_all_cleaners(options)
+      test_type     = options[:test_type] || @test_type
+      test_strategy = options[:test_strategy] || @test_strategy
+      run_all_cleaners("#{test_type}_end".to_sym, @cleaners.reverse, test_strategy)
+    end
+
+    def reset_suite
+      run_all_cleaners(:reset_suite, @cleaners.reverse)
+    end
+
+    def run_all_cleaners(cleaner_function, cleaners, *args, &block)
+      last_error = nil
+
+      cleaners.each do |cleaner|
+        begin
+          if cleaner.respond_to?(cleaner_function)
+            cleaner.send(cleaner_function, *args, &block)
+          end
+        rescue => error
+          PseudoCleaner::MasterCleaner.process_exception(last_error) if last_error
+
+          last_error = error
+        end
+      end
+
+      raise last_error if last_error
+    end
+
+    def review_rows(&block)
+      run_all_cleaners(:review_rows, @cleaners, &block)
+    end
+  end
+end