pseudo_cleaner 0.0.30 → 0.0.31

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWQ1NjM5ZjVhZThkYTAwMzBmMGUzYjNjZjg1OTI5ODdhZTg0ZWY3Mw==
+    NjMyOGI1MjJmODFhYzMwZmJjMzY2NzA3MGMyY2U3ODNiMzEyOTc4Yg==
   data.tar.gz: !binary |-
-    ODFkNjg4NWJmZTNkZGI0MDdhYWE0MjYyMTI2YjQ4M2RjYWJlYWJiYQ==
+    OTM2ZmI1ZmViZmYzZTZhODBiMjA4MmNhMWNiNDIxMzFiNTQyYjZjMQ==
 SHA512:
   metadata.gz: !binary |-
-    YjBlMGFjN2E2MzVjMGI5NmIzOGM2MzU1NWVjMTE2NjA0YWVhYWM3NDdhNThh
-    MGViMTMxZTQyYmI3YzUxOTcxYTcxMDgyZDlmZjI4NjBlNDlhZGNmOGM1MTMy
-    NDY3YmQ0MTkxYWRhNWU1NWRmY2I4MTIzMjliMjcwZjI1ZGFlM2E=
+    MTRhNjIxN2Y1OWFkMGIxMDA4YTliOWRkM2RiNzgwNzM3Y2QzNjJkMzE1MTdm
+    NDc5OGE5ODBjM2Q5MzZjM2QwYjkwYjA2MzIxMTVlOWIwZDg2M2VhNTU0ZGY0
+    MzVmOTkxODI1YzQ3ZDAwZWZjMWQxYzJkNGQ1YzRlOWRiNGU2ODU=
   data.tar.gz: !binary |-
-    NGNhYWY0Y2M0YmY3YWY0YjllMzllY2U4NDY2Njg3YjEyMTcxMmY1ZjdiMWMw
-    M2Q4OWRiYzk0MzFhOGVjMTFiMjY1NDE1MDI0MzU2MmMyNWRjMDZmZmRmNzVm
-    MDU5NGRlZGQyYzM2NTRiMWI3ZjUwZDA3NjFkZTA3M2Y3MDBmZjA=
+    Zjg3NWQ1NGY1OTkyOTQxOWY5NzAyNzM2MDZkZjE4YzhlYjU2ZjhmMjFjNTNl
+    MWVhM2E0NjAyOTY3ODQ2Mjg1MTcxYTgxYmZiOGM1MDRmYjgxMmUzN2E2YzM2
+    NzI2OGM5N2FkMTVjMTA0OGM5NDI0YzU2YjM2OWY1YWU4ZDNlMWY=

data/README.md

@@ -61,6 +61,9 @@ To integrate the PseudoCleaner with Rspec, simply add the following lines to `sp
     require 'pseudo_cleaner'
     require 'pseudo_cleaner/rspec'
 
+Add the lines as early as possible in the spec_helper because the hooks used are before and after hooks.  Adding the 
+hooks early will wrap other hooks in the transaction.
+
 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.
 
@@ -85,7 +88,16 @@ Example:
 
 ### Cucumber
 
-Cucumber integration similar to Rspec integration is planned, but not implemented yet.
+Cucumber integration similar to Rspec integration simply add the cucumber hook file instead.
+
+    require 'pseudo_cleaner'
+    require 'pseudo_cleaner/cucumber'
+
+### Spinach
+
+Spinach integration hasn't been fully tested.
+
+It probably should work.
 
 ### Manual
 

data/lib/pseudo_cleaner/configuration.rb

@@ -1,6 +1,8 @@
+require "singleton"
+
 module PseudoCleaner
   class Configuration
-    @@current_instance = nil
+    include Singleton
 
     # A simple configuration class for the PseudoCleaner
     #
@@ -12,33 +14,63 @@ module PseudoCleaner
     attr_accessor :reset_auto_increment
     attr_accessor :single_cleaner_set
     attr_accessor :post_transaction_analysis
+    attr_accessor :db_connections
 
     def self.current_instance
-      @@current_instance ||= PseudoCleaner::Configuration.new
+      self.instance
     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
+      @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
+      @db_connections              = {}
     end
 
+    # Backwards comaptibility...
     def self.db_connection=(connection)
-      @db_connection = connection
+      self.instance.db_connection = connection
     end
 
     def self.db_connection(type)
-      if @db_connection || type.nil?
-        @db_connection
-      else
-        if type == :sequel
-          Sequel::DATABASES[0]
+      self.instance.db_connection(type)
+    end
+
+    def db_connection=(connection)
+      if Object.const_defined?("ActiveRecord", false) && ActiveRecord.const_defined?("Base", false)
+        table_is_active_record = connection.class == ActiveRecord::Base
+        table_super_class      = connection.class.superclass if connection.class
+        while !table_is_active_record && table_super_class
+          table_is_active_record = (table_super_class == ActiveRecord::Base)
+          table_super_class      = table_super_class.superclass
+        end
+
+        @db_connections[:active_record] = connection if table_is_active_record
+      end
+
+      if Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+        @db_connections[:sequel] = connection
+      end
+    end
+
+    def db_connection(type)
+      if (!type)
+        if Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+          type = :sequel
         else
-          ActiveRecord::Base
+          type = :active_record
         end
       end
+
+      if type == :sequel
+        @db_connections[type] ||= Sequel::DATABASES[0]
+      else
+        @db_connections[type] ||= ActiveRecord::Base
+      end
+
+      @db_connections[type]
     end
   end
 end

data/lib/pseudo_cleaner/cucumber.rb

@@ -75,7 +75,7 @@ end
 #
 # I hope that this gets fixed, but until it does, we can't use Around for database cleaning.
 #
-# This is fixed in Cucumber 2.0.
+# This was fixed in Cucumber 2.0.
 
 
 if Cucumber::VERSION.split[0].to_i >= 2

data/lib/pseudo_cleaner/master_cleaner.rb

@@ -30,6 +30,14 @@ module PseudoCleaner
         @@suite_cleaner
       end
 
+      def database_cleaner
+        if Object.const_defined?("ActiveRecord", false) && ActiveRecord.const_defined?("Base", false)
+          DatabaseCleaner[:active_record, connection: PseudoCleaner::Configuration.db_connection(:active_record)]
+        elsif Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+          DatabaseCleaner[:sequel, connection: PseudoCleaner::Configuration.db_connection(:sequel)]
+        end
+      end
+
       def start_example(example_class, strategy)
         pseudo_cleaner_data                 = {}
         pseudo_cleaner_data[:test_strategy] = strategy
@@ -39,13 +47,7 @@ module PseudoCleaner
 
           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
+            PseudoCleaner::MasterCleaner.database_cleaner.start
           end
 
           pseudo_cleaner_data[:pseudo_state] = PseudoCleaner::MasterCleaner.start_test strategy
@@ -59,13 +61,7 @@ module PseudoCleaner
 
         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
+            PseudoCleaner::MasterCleaner.database_cleaner.clean
           end
 
           case pseudo_cleaner_data[:test_strategy]
@@ -114,7 +110,7 @@ module PseudoCleaner
       end
 
       def reset_database
-        DatabaseCleaner.clean_with(:truncation)
+        PseudoCleaner::MasterCleaner.database_cleaner.clean_with(:truncation)
 
         PseudoCleaner::MasterCleaner.database_reset
       end
@@ -358,15 +354,17 @@ module PseudoCleaner
     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
+      if cleaners
+        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
+            last_error = error
+          end
         end
       end
 

data/lib/pseudo_cleaner/rspec.rb

@@ -15,9 +15,23 @@ RSpec.configure do |config|
     PseudoCleaner::MasterCleaner.end_suite
   end
 
-  config.around(:each) do |example|
+  # I tried making this a config.around(:each).
+  # You can't do that.  It turns out that RSpec injects a virtual around(:each) that
+  # calls after_teardown which calls ActiveRecord::Base.clear_active_connections!
+  #
+  # This resets the active connection.
+  #
+  # If (for whatever reason) there are multiple connections in the connection pool this
+  # means that when you go to clean, the connection has been released, and when
+  # DatabaseCleaner tries to get a new connection, it may not get the same one it had
+  # when start was called.
+  #
+  # By using before and after, we avoid this problem by being inside the around block.
+  # The compromize is that the user will be more load dependent to get the hooks
+  # in the right order (potentially).
+  config.before(:each) do |example|
+    test_example = example
     test_example = example.example if example.respond_to?(:example)
-    test_example ||= self.example if self.respond_to?(:example)
 
     new_strategy = nil
 
@@ -34,11 +48,12 @@ RSpec.configure do |config|
     new_strategy ||= :transaction
 
     PseudoCleaner::MasterCleaner.start_example(test_example, new_strategy)
+  end
 
-    begin
-      example.run
-    ensure
-      PseudoCleaner::MasterCleaner.end_example(test_example)
-    end
+  config.after(:each) do |example|
+    test_example = example
+    test_example = example.example if example.respond_to?(:example)
+
+    PseudoCleaner::MasterCleaner.end_example(test_example)
   end
 end

data/lib/pseudo_cleaner/table_cleaner.rb

@@ -190,14 +190,14 @@ module PseudoCleaner
     end
 
     def test_end test_strategy
-      reset_table test_strategy
+      reset_table test_strategy, false
     end
 
     def suite_end test_strategy
-      reset_table test_strategy
+      reset_table test_strategy, true
     end
 
-    def reset_table test_strategy
+    def reset_table test_strategy, require_output
       if @test_strategy != test_strategy && !PseudoCleaner::Configuration.current_instance.single_cleaner_set
         if @options[:output_diagnostics]
           PseudoCleaner::Logger.write("  *** The ending strategy for \"#{initial_state[:table_name]}\" changed! ***".red.on_light_white)
@@ -216,19 +216,23 @@ module PseudoCleaner
         # I'm using it because it is faster than reseeding each test...
         # And, I can be responsible for worrying about referential integrity in the test
         # if I want to...
-        PseudoCleaner::Logger.write("  Resetting table \"#{initial_state[:table_name]}\"...") if @options[:output_diagnostics]
+        pre_string    = "  Resetting table \"#{initial_state[:table_name]}\" for #{test_strategy}..."
+        pre_string    = "Tests ended without cleaning up properly!!!\n" + pre_string if require_output
+        pre_string    = pre_string.red.on_light_white if require_output
+
+        require_output ||= @options[:output_diagnostics]
 
         if initial_state[:table_is_active_record]
-          test_end_active_record test_strategy
+          test_end_active_record test_strategy, pre_string, require_output
         end
 
         if initial_state[:table_is_sequel_model]
-          test_end_sequel_model test_strategy
+          test_end_sequel_model test_strategy, pre_string, require_output
         end
       end
     end
 
-    def test_end_active_record test_strategy
+    def test_end_active_record test_strategy, pre_string, require_output
       initial_state = @@initial_states[@table]
       cleaned_table = false
 
@@ -243,7 +247,10 @@ module PseudoCleaner
         if num_deleted > 0
           cleaned_table = true
 
-          output_delete_record(test_strategy, "    Deleted #{num_deleted} records by ID.")
+          pre_string = output_delete_record(test_strategy,
+                                            "    Deleted #{num_deleted} records by ID.",
+                                            pre_string,
+                                            require_output)
         end
       end
 
@@ -255,7 +262,10 @@ module PseudoCleaner
         if num_deleted > 0
           cleaned_table = true
 
-          output_delete_record(test_strategy, "    Deleted #{num_deleted} records by #{initial_state[:created][:column_name]}.")
+          pre_string = output_delete_record(test_strategy,
+                                            "    Deleted #{num_deleted} records by #{initial_state[:created][:column_name]}.",
+                                            pre_string,
+                                            require_output)
         end
       end
 
@@ -263,14 +273,16 @@ module PseudoCleaner
         dirty_count = PseudoCleaner::Configuration.db_connection(:active_record).connection.
             execute("SELECT COUNT(*) FROM `#{table_name}` WHERE #{initial_state[:updated][:column_name]} > '#{initial_state[:updated][:value]}'").first[0]
 
-        if @options[:output_diagnostics] && dirty_count > 0
+        if require_output && dirty_count > 0
           # cleaned_table = true
 
           initial_state[:updated][:value] = PseudoCleaner::Configuration.db_connection(:active_record).connection.
               execute("SELECT MAX(#{initial_state[:updated][:column_name]}) FROM `#{table_name}`").first[0]
 
-          PseudoCleaner::Logger.write("  Resetting table \"#{initial_state[:table_name]}\"...") unless @options[:output_diagnostics]
-          output_delete_record(test_strategy, "    *** There are #{dirty_count} records which have been updated and may be dirty remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white)
+          pre_string = output_delete_record(test_strategy,
+                                            "    *** There are #{dirty_count} records which have been updated and may be dirty remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white,
+                                            pre_string,
+                                            require_output)
         end
       end
 
@@ -282,7 +294,12 @@ module PseudoCleaner
 
           DatabaseCleaner[:active_record, connection: PseudoCleaner::Configuration.db_connection(:active_record)].
               clean_with(:truncation, only: [initial_state[:table_name]])
-          output_delete_record(test_strategy, "    Deleted #{final_count} records by cleaning the table.") if final_count > 0
+          if final_count > 0
+            pre_string = output_delete_record(test_strategy,
+                                              "    Deleted #{final_count} records by cleaning the table.",
+                                              pre_string,
+                                              require_output)
+          end
 
           final_count = PseudoCleaner::Configuration.db_connection(:active_record).connection.
               execute("SELECT COUNT(*) FROM `#{table_name}`").first[0]
@@ -290,10 +307,10 @@ module PseudoCleaner
       end
 
       if initial_state[:count] != final_count
-        PseudoCleaner::Logger.write("  Resetting table \"#{initial_state[:table_name]}\"...") unless @options[:output_diagnostics]
-        output_delete_record(test_strategy,
-                             "    *** There are #{final_count - initial_state[:count]} dirty records remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white,
-                             true)
+        pre_string = output_delete_record(test_strategy,
+                                          "    *** There are #{final_count - initial_state[:count]} dirty records remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white,
+                                          pre_string,
+                                          true)
 
         initial_state[:count] = final_count
         cleaned_table         = true
@@ -304,7 +321,7 @@ module PseudoCleaner
       end
     end
 
-    def test_end_sequel_model test_strategy
+    def test_end_sequel_model test_strategy, pre_string, require_output
       initial_state = @@initial_states[@table]
       access_table  = sequel_model_table
       cleaned_table = false
@@ -316,7 +333,10 @@ module PseudoCleaner
           if num_deleted > 0
             cleaned_table = true
 
-            output_delete_record(test_strategy, "    Deleted #{num_deleted} records by ID.")
+            pre_string = output_delete_record(test_strategy,
+                                              "    Deleted #{num_deleted} records by ID.",
+                                              pre_string,
+                                              require_output)
           end
         end
 
@@ -328,7 +348,10 @@ module PseudoCleaner
           if num_deleted > 0
             cleaned_table = true
 
-            output_delete_record(test_strategy, "    Deleted #{num_deleted} records by #{initial_state[:created][:column_name]}.")
+            pre_string = output_delete_record(test_strategy,
+                                              "    Deleted #{num_deleted} records by #{initial_state[:created][:column_name]}.",
+                                              pre_string,
+                                              require_output)
           end
         end
 
@@ -338,13 +361,15 @@ module PseudoCleaner
               where("`#{initial_state[:updated][:column_name]}` > ?", initial_state[:updated][:value]).
               count
 
-          if @options[:output_diagnostics] && dirty_count > 0
+          if require_output && dirty_count > 0
             # cleaned_table = true
 
             initial_state[:updated][:value] = access_table.unfiltered.max(initial_state[:updated][:column_name])
 
-            PseudoCleaner::Logger.write("  Resetting table \"#{initial_state[:table_name]}\"...") unless @options[:output_diagnostics]
-            output_delete_record(test_strategy, "    *** There are #{dirty_count} records which have been updated and may be dirty remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white)
+            pre_string = output_delete_record(test_strategy,
+                                              "    *** There are #{dirty_count} records which have been updated and may be dirty remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white,
+                                              pre_string,
+                                              require_output)
           end
         end
 
@@ -355,17 +380,22 @@ module PseudoCleaner
 
             DatabaseCleaner[:sequel, connection: PseudoCleaner::Configuration.db_connection(:sequel)].
                 clean_with(:truncation, only: [initial_state[:table_name]])
-            output_delete_record(test_strategy, "    Deleted #{final_count} records by cleaning the table.") if final_count > 0
+            if final_count > 0
+              pre_string = output_delete_record(test_strategy,
+                                                "    Deleted #{final_count} records by cleaning the table.",
+                                                pre_string,
+                                                require_output)
+            end
 
             final_count = access_table.unfiltered.count
           end
         end
 
         if initial_state[:count] != final_count
-          PseudoCleaner::Logger.write("  Resetting table \"#{initial_state[:table_name]}\"...") unless @options[:output_diagnostics]
-          output_delete_record(test_strategy,
-                               "    *** There are #{final_count - initial_state[:count]} dirty records remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white,
-                               true)
+          pre_string = output_delete_record(test_strategy,
+                                            "    *** There are #{final_count - initial_state[:count]} dirty records remaining after cleaning \"#{initial_state[:table_name]}\"... ***".red.on_light_white,
+                                            pre_string,
+                                            true)
 
           initial_state[:count] = final_count
           cleaned_table         = true
@@ -377,11 +407,14 @@ module PseudoCleaner
       end
     end
 
-    def output_delete_record(test_strategy, stats_string, require_output = false)
+    def output_delete_record(test_strategy, stats_string, pre_string, require_output = false)
+      PseudoCleaner::Logger.write(pre_string) if pre_string && (@options[:output_diagnostics] || require_output)
       if test_strategy == :transaction
         PseudoCleaner::Logger.write("    ***** TRANSACTION FAILED!!! *****".red.on_light_white)
       end
       PseudoCleaner::Logger.write(stats_string) if @options[:output_diagnostics] || require_output
+
+      nil
     end
 
     def reset_auto_increment test_start
@@ -489,12 +522,14 @@ module PseudoCleaner
     def review_rows(&block)
       initial_state = @@initial_states[@table]
 
-      if initial_state[:table_is_active_record]
-        review_rows_active_record &block
-      end
+      if initial_state
+        if initial_state[:table_is_active_record]
+          review_rows_active_record &block
+        end
 
-      if initial_state[:table_is_sequel_model]
-        review_rows_sequel_model &block
+        if initial_state[:table_is_sequel_model]
+          review_rows_sequel_model &block
+        end
       end
     end
 

data/lib/pseudo_cleaner/version.rb

@@ -1,3 +1,3 @@
 module PseudoCleaner
-  VERSION = "0.0.30"
+  VERSION = "0.0.31"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pseudo_cleaner
 version: !ruby/object:Gem::Version
-  version: 0.0.30
+  version: 0.0.31
 platform: ruby
 authors:
 - RealNobody
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2015-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize