pseudo_cleaner 0.0.34 → 0.0.35

data/lib/pseudo_cleaner/rspec.rb

@@ -47,13 +47,40 @@ RSpec.configure do |config|
     end
     new_strategy ||= :transaction
 
-    PseudoCleaner::MasterCleaner.start_example(test_example, new_strategy)
+    report_name = test_example.full_description
+    PseudoCleaner::MasterCleaner.start_example(test_example, new_strategy, "PseudoCleaner::start_test - #{report_name}")
   end
 
   config.after(:each) do |example|
     test_example = example
     test_example = example.example if example.respond_to?(:example)
 
-    PseudoCleaner::MasterCleaner.end_example(test_example)
+    report_name = test_example.full_description
+
+    if test_example.metadata[:full_data_dump]
+      if (test_example.exception)
+        if PseudoCleaner::Configuration.instance.enable_full_data_dump_tag ||
+            PseudoCleaner::Configuration.instance.peek_data_on_error
+          PseudoCleaner::MasterCleaner.peek_data_inline("PseudoCleaner::peek_data - #{report_name}")
+        end
+      else
+        if PseudoCleaner::Configuration.instance.enable_full_data_dump_tag ||
+            PseudoCleaner::Configuration.instance.peek_data_not_on_error
+          PseudoCleaner::MasterCleaner.peek_data_new_test("PseudoCleaner::peek_data - #{report_name}")
+        end
+      end
+    else
+      if (test_example.exception)
+        if PseudoCleaner::Configuration.instance.peek_data_on_error
+          PseudoCleaner::MasterCleaner.peek_data_inline("PseudoCleaner::peek_data - #{report_name}")
+        end
+      else
+        if PseudoCleaner::Configuration.instance.peek_data_not_on_error
+          PseudoCleaner::MasterCleaner.peek_data_new_test("PseudoCleaner::peek_data - #{report_name}")
+        end
+      end
+    end
+
+    PseudoCleaner::MasterCleaner.end_example(test_example, "PseudoCleaner::end_test - #{report_name}")
   end
 end

data/lib/pseudo_cleaner/spinach.rb

@@ -1,8 +1,20 @@
+require "singleton"
+
 first_test_run = false
 
 # I haven't tested this fully yet, but I think that this should work.
 
+module PseudoCleaner
+  class SpinachErrorHandler
+    attr_accessor :exception
+
+    include Singleton
+  end
+end
+
 Spinach.hooks.around_scenario do |scenario_data, step_definitions, &block|
+  PseudoCleaner::SpinachErrorHandler.exception = nil
+
   unless first_test_run
     first_test_run = true
     # before tests run...
@@ -16,24 +28,58 @@ Spinach.hooks.around_scenario do |scenario_data, step_definitions, &block|
     DatabaseCleaner.strategy = :transaction
   end
 
-  strategy = if scenario_data.tags.include?("@none")
-               :none
-             elsif scenario_data.tags.include?("@truncation")
-               :truncation
-             elsif scenario_data.tags.include?("@deletion")
-               :deletion
-             else
-               :pseudo_delete
-             end
-  PseudoCleaner::MasterCleaner.start_example(scenario_data, strategy)
+  report_name = "#{scenario_data.feature.name} : #{scenario_data.name}"
+  strategy    = if scenario_data.tags.include?("@none")
+                  :none
+                elsif scenario_data.tags.include?("@truncation")
+                  :truncation
+                elsif scenario_data.tags.include?("@deletion")
+                  :deletion
+                else
+                  :pseudo_delete
+                end
+  PseudoCleaner::MasterCleaner.start_example(scenario_data, strategy, "PseudoCleaner::start_test - #{report_name}")
 
   begin
     block.call
   ensure
-    PseudoCleaner::MasterCleaner.end_example(scenario_data)
+    if scenario_data.tags.include?("@full_data_dump")
+      if PseudoCleaner::SpinachErrorHandler.exception
+        if PseudoCleaner::Configuration.instance.enable_full_data_dump_tag ||
+            PseudoCleaner::Configuration.instance.peek_data_on_error
+          PseudoCleaner::MasterCleaner.peek_data_inline("PseudoCleaner::peek_data - #{report_name}")
+        end
+      else
+        if PseudoCleaner::Configuration.instance.enable_full_data_dump_tag ||
+            PseudoCleaner::Configuration.instance.peek_data_not_on_error
+          PseudoCleaner::MasterCleaner.peek_data_new_test("PseudoCleaner::peek_data - #{report_name}")
+        end
+      end
+    else
+      if PseudoCleaner::SpinachErrorHandler.exception
+        if PseudoCleaner::Configuration.instance.peek_data_on_error
+          PseudoCleaner::MasterCleaner.peek_data_inline("PseudoCleaner::peek_data - #{report_name}")
+        end
+      else
+        if PseudoCleaner::Configuration.instance.peek_data_not_on_error
+          PseudoCleaner::MasterCleaner.peek_data_new_test("PseudoCleaner::peek_data - #{report_name}")
+        end
+      end
+    end
+
+    PseudoCleaner::MasterCleaner.end_example(scenario_data, "PseudoCleaner::end_test - #{report_name}")
+    PseudoCleaner::SpinachErrorHandler.exception = nil
   end
 end
 
+Spinach.hooks.on_failed_step do |step_data, exception, location, step_definitions|
+  PseudoCleaner::SpinachErrorHandler.exception = exception
+end
+
+Spinach.hooks.on_error_step do |step_data, exception, location, step_definitions|
+  PseudoCleaner::SpinachErrorHandler.exception = exception
+end
+
 Spinach.hooks.after_run do |status|
   # We end suite in case a custom cleaner wants/needs to.
   PseudoCleaner::MasterCleaner.end_suite

data/lib/pseudo_cleaner/table_cleaner.rb

@@ -78,30 +78,58 @@ module PseudoCleaner
       save_state
     end
 
+    def within_report_block(description, conditional, &block)
+      @report_table = nil
+
+      if PseudoCleaner::MasterCleaner.report_table || conditional
+        Cornucopia::Util::ReportTable.new(nested_table:         PseudoCleaner::MasterCleaner.report_table,
+                                          nested_table_label:   description,
+                                          suppress_blank_table: true) do |sub_report|
+          @report_table = sub_report
+
+          block.yield
+        end
+      else
+        block.yield
+      end
+
+      @report_table = nil
+    end
+
     def save_state
       initial_state = @@initial_states[@table]
 
       if @test_strategy == :pseudo_delete && !initial_state[:saved]
         initial_state[:saved] = true
 
-        if @options[:output_diagnostics]
-          PseudoCleaner::Logger.write("  Gathering information about \"#{initial_state[:table_name]}\"...".blue.on_light_white)
-        end
+        within_report_block(initial_state[:table_name], @options[:output_diagnostics]) do
+          if @options[:output_diagnostics]
+            PseudoCleaner::MasterCleaner.report_error
 
-        if initial_state[:table_is_active_record]
-          test_start_active_record @test_strategy
-        end
+            unless @report_table
+              PseudoCleaner::Logger.write("  Gathering information about \"#{initial_state[:table_name]}\"...".blue.on_light_white)
+            end
+          end
 
-        if initial_state[:table_is_sequel_model]
-          test_start_sequel_model @test_strategy
-        end
+          if initial_state[:table_is_active_record]
+            test_start_active_record @test_strategy
+          end
 
-        if PseudoCleaner::Configuration.current_instance.reset_auto_increment
-          reset_auto_increment !PseudoCleaner::Configuration.current_instance.clean_database_before_tests
-        end
+          if initial_state[:table_is_sequel_model]
+            test_start_sequel_model @test_strategy
+          end
 
-        if initial_state.has_key?(:count) && @options[:output_diagnostics]
-          PseudoCleaner::Logger.write("    *** There are no columns to track inserts and updates easily on for #{initial_state[:table_name]} ***".red.on_light_white)
+          if PseudoCleaner::Configuration.current_instance.reset_auto_increment
+            reset_auto_increment !PseudoCleaner::Configuration.current_instance.clean_database_before_tests
+          end
+
+          if initial_state.has_key?(:count) && @options[:output_diagnostics]
+            if @report_table
+              @report_table.write_stats "", "*** There are no columns to track inserts and updates easily on for #{initial_state[:table_name]} ***"
+            else
+              PseudoCleaner::Logger.write("    *** There are no columns to track inserts and updates easily on for #{initial_state[:table_name]} ***".red.on_light_white)
+            end
+          end
         end
       end
     end
@@ -125,7 +153,14 @@ module PseudoCleaner
       if PseudoCleaner::Configuration.db_connection(:active_record).connection.columns(table_name).find { |column| column.name == "id" }
         new_state[:max_id] = PseudoCleaner::Configuration.db_connection(:active_record).connection.
             execute("SELECT MAX(`id`) FROM `#{table_name}`").first[0] || 0
-        PseudoCleaner::Logger.write("    max(id) = #{new_state[:max_id]}") if @options[:output_diagnostics]
+
+        if @options[:output_diagnostics]
+          if @report_table
+            @report_table.write_stats("max(id)", new_state[:max_id])
+          else
+            PseudoCleaner::Logger.write("    max(id) = #{new_state[:max_id]}")
+          end
+        end
       end
 
       [:created, :updated].each do |date_name|
@@ -134,14 +169,19 @@ module PseudoCleaner
 
           if PseudoCleaner::Configuration.db_connection(:active_record).connection.
               columns(table_name).find { |column| column.name == date_column_name }
-            new_state[date_name] = {
+            new_state[date_name]                 = {
                 column_name: date_column_name,
                 value:       PseudoCleaner::Configuration.db_connection(:active_record).connection.
                     execute("SELECT MAX(`#{date_column_name}`) FROM `#{table_name}`").first[0] ||
                                  Time.now - 1.second
             }
+            new_state[date_name][:initial_value] = new_state[date_name][:value]
             if @options[:output_diagnostics]
-              PseudoCleaner::Logger.write("    max(#{new_state[date_name][:column_name]}) = #{new_state[date_name][:value]}")
+              if @report_table
+                @report_table.write("max(#{new_state[date_name][:column_name]})", new_state[date_name][:value])
+              else
+                PseudoCleaner::Logger.write("    max(#{new_state[date_name][:column_name]}) = #{new_state[date_name][:value]}")
+              end
             end
 
             break
@@ -162,7 +202,13 @@ module PseudoCleaner
 
       if access_table.columns.include?(:id)
         new_state[:max_id] = access_table.unfiltered.max(:id) || 0
-        PseudoCleaner::Logger.write("    max(id) = #{new_state[:max_id]}") if @options[:output_diagnostics]
+        if @options[:output_diagnostics]
+          if @report_table
+            @report_table.write_stats("max(id)", new_state[:max_id])
+          else
+            PseudoCleaner::Logger.write("    max(id) = #{new_state[:max_id]}")
+          end
+        end
       end
 
       [:created, :updated].each do |date_name|
@@ -170,12 +216,17 @@ module PseudoCleaner
           date_column_name = "#{date_name}_#{verb_name}".to_sym
 
           if access_table.columns.include?(date_column_name)
-            new_state[date_name] = {
+            new_state[date_name]                 = {
                 column_name: date_column_name,
                 value:       access_table.unfiltered.max(date_column_name) || Time.now - 1.second
             }
+            new_state[date_name][:initial_value] = new_state[date_name][:value]
             if @options[:output_diagnostics]
-              PseudoCleaner::Logger.write("    max(#{new_state[date_name][:column_name]}) = #{new_state[date_name][:value]}")
+              if @report_table
+                @report_table.write_stats("max(#{new_state[date_name][:column_name]})", new_state[date_name][:value])
+              else
+                PseudoCleaner::Logger.write("    max(#{new_state[date_name][:column_name]}) = #{new_state[date_name][:value]}")
+              end
             end
 
             break
@@ -190,23 +241,37 @@ module PseudoCleaner
     end
 
     def test_end test_strategy
-      reset_table test_strategy, false
+      initial_state = @@initial_states[@table]
+
+      within_report_block(initial_state[:table_name], @options[:output_diagnostics]) do
+        reset_table test_strategy, false, false
+      end
     end
 
     def suite_end test_strategy
-      reset_table test_strategy, true
+      initial_state = @@initial_states[@table]
+
+      within_report_block(initial_state[:table_name], @options[:output_diagnostics]) do
+        reset_table test_strategy, true, true
+      end
     end
 
-    def reset_table test_strategy, require_output
+    def reset_table test_strategy, require_output, is_suite_end
+      initial_state = @@initial_states[@table]
+
       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)
+          PseudoCleaner::MasterCleaner.report_error
+
+          if @report_table
+            @report_table.write_stats("WARNING", "*** The ending strategy for \"#{initial_state[:table_name]}\" changed! ***")
+          else
+            PseudoCleaner::Logger.write("  *** The ending strategy for \"#{initial_state[:table_name]}\" changed! ***".red.on_light_white)
+          end
         end
       end
 
       if test_strategy == :pseudo_delete || PseudoCleaner::Configuration.current_instance.post_transaction_analysis
-        initial_state = @@initial_states[@table]
-
         # we should check the relationships for any records which still refer to
         # a now deleted record.  (i.e. if we updated a record to refer to a record)
         # we deleted...
@@ -216,23 +281,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...
-        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
+        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, pre_string, require_output
+          test_end_active_record test_strategy, pre_string, require_output, is_suite_end
         end
 
         if initial_state[:table_is_sequel_model]
-          test_end_sequel_model test_strategy, pre_string, require_output
+          test_end_sequel_model test_strategy, pre_string, require_output, is_suite_end
         end
       end
     end
 
-    def test_end_active_record test_strategy, pre_string, require_output
+    def test_end_active_record test_strategy, pre_string, require_output, is_suite_end
       initial_state = @@initial_states[@table]
       cleaned_table = false
 
@@ -249,6 +314,8 @@ module PseudoCleaner
 
           pre_string = output_delete_record(test_strategy,
                                             "    Deleted #{num_deleted} records by ID.",
+                                            "Deleted",
+                                            "#{num_deleted} records by ID",
                                             pre_string,
                                             require_output)
         end
@@ -264,16 +331,23 @@ module PseudoCleaner
 
           pre_string = output_delete_record(test_strategy,
                                             "    Deleted #{num_deleted} records by #{initial_state[:created][:column_name]}.",
+                                            "Deleted",
+                                            "#{num_deleted} records by #{initial_state[:created][:column_name]}",
                                             pre_string,
                                             require_output)
         end
       end
 
-      if initial_state[:updated]
+      if initial_state[:updated] && !ignore_updates
+        test_value = initial_state[:updated][:value]
+        if is_suite_end
+          test_value = initial_state[:updated][:initial_value]
+        end
+
         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]
+            execute("SELECT COUNT(*) FROM `#{table_name}` WHERE #{initial_state[:updated][:column_name]} > '#{test_value}'").first[0]
 
-        if require_output && dirty_count > 0
+        if dirty_count > 0
           # cleaned_table = true
 
           initial_state[:updated][:value] = PseudoCleaner::Configuration.db_connection(:active_record).connection.
@@ -281,6 +355,8 @@ module PseudoCleaner
 
           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,
+                                            "WARNING",
+                                            "*** There are #{dirty_count} records which have been updated and may be dirty remaining after cleaning \"#{initial_state[:table_name]}\"... ***",
                                             pre_string,
                                             require_output)
         end
@@ -297,6 +373,8 @@ module PseudoCleaner
           if final_count > 0
             pre_string = output_delete_record(test_strategy,
                                               "    Deleted #{final_count} records by cleaning the table.",
+                                              "Deleted",
+                                              "#{final_count} records by cleaning the table",
                                               pre_string,
                                               require_output)
           end
@@ -309,6 +387,8 @@ module PseudoCleaner
       if initial_state[:count] != final_count
         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,
+                                          "WARNING",
+                                          "*** There are #{final_count - initial_state[:count]} dirty records remaining after cleaning \"#{initial_state[:table_name]}\"... ***",
                                           pre_string,
                                           true)
 
@@ -321,7 +401,11 @@ module PseudoCleaner
       end
     end
 
-    def test_end_sequel_model test_strategy, pre_string, require_output
+    def ignore_updates
+      false
+    end
+
+    def test_end_sequel_model test_strategy, pre_string, require_output, is_suite_end
       initial_state = @@initial_states[@table]
       access_table  = sequel_model_table
       cleaned_table = false
@@ -335,6 +419,8 @@ module PseudoCleaner
 
             pre_string = output_delete_record(test_strategy,
                                               "    Deleted #{num_deleted} records by ID.",
+                                              "Deleted",
+                                              "#{num_deleted} records by ID",
                                               pre_string,
                                               require_output)
           end
@@ -350,24 +436,33 @@ module PseudoCleaner
 
             pre_string = output_delete_record(test_strategy,
                                               "    Deleted #{num_deleted} records by #{initial_state[:created][:column_name]}.",
+                                              "Deleted",
+                                              "#{num_deleted} records by #{initial_state[:created][:column_name]}",
                                               pre_string,
                                               require_output)
           end
         end
 
-        if initial_state[:updated]
+        if initial_state[:updated] && !ignore_updates
+          test_value = initial_state[:updated][:value]
+          if is_suite_end
+            test_value = initial_state[:updated][:initial_value]
+          end
+
           dirty_count = access_table.
               unfiltered.
-              where("`#{initial_state[:updated][:column_name]}` > ?", initial_state[:updated][:value]).
+              where("`#{initial_state[:updated][:column_name]}` > ?", test_value).
               count
 
-          if require_output && dirty_count > 0
+          if dirty_count > 0
             # cleaned_table = true
 
             initial_state[:updated][:value] = access_table.unfiltered.max(initial_state[:updated][:column_name])
 
             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,
+                                              "WARNING",
+                                              "*** There are #{dirty_count} records which have been updated and may be dirty remaining after cleaning \"#{initial_state[:table_name]}\"... ***",
                                               pre_string,
                                               require_output)
           end
@@ -383,6 +478,8 @@ module PseudoCleaner
             if final_count > 0
               pre_string = output_delete_record(test_strategy,
                                                 "    Deleted #{final_count} records by cleaning the table.",
+                                                "Deleted",
+                                                "#{final_count} records by cleaning the table",
                                                 pre_string,
                                                 require_output)
             end
@@ -394,6 +491,8 @@ module PseudoCleaner
         if initial_state[:count] != final_count
           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,
+                                            "WARNING",
+                                            "*** There are #{final_count - initial_state[:count]} dirty records remaining after cleaning \"#{initial_state[:table_name]}\"... ***",
                                             pre_string,
                                             true)
 
@@ -407,12 +506,29 @@ module PseudoCleaner
       end
     end
 
-    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)
+    def output_delete_record(test_strategy,
+                             stats_string,
+                             table_label,
+                             table_value,
+                             pre_string,
+                             require_output = false)
+      if pre_string && !@report_table && (@options[:output_diagnostics] || require_output)
+        PseudoCleaner::Logger.write(pre_string)
+      end
+
       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
+
+      if @options[:output_diagnostics] || require_output
+        PseudoCleaner::MasterCleaner.report_error
+
+        if @report_table
+          @report_table.write_stats(table_label, table_value)
+        else
+          PseudoCleaner::Logger.write(stats_string)
+        end
+      end
 
       nil
     end
@@ -439,7 +555,11 @@ module PseudoCleaner
 
         unless table_name.blank?
           if @options[:output_diagnostics]
-            PseudoCleaner::Logger.write("    ALTER TABLE #{table_name} AUTO_INCREMENT = #{initial_state[:max_id] + 1}")
+            if @report_table
+              @report_table.write_stats("AUTO_INCREMENT", initial_state[:max_id] + 1)
+            else
+              PseudoCleaner::Logger.write("    ALTER TABLE #{table_name} AUTO_INCREMENT = #{initial_state[:max_id] + 1}")
+            end
           end
 
           PseudoCleaner::Configuration.db_connection(:active_record).connection.
@@ -456,7 +576,11 @@ module PseudoCleaner
 
         unless table_name.blank?
           if @options[:output_diagnostics]
-            PseudoCleaner::Logger.write("    ALTER TABLE #{table_name} AUTO_INCREMENT = #{initial_state[:max_id] + 1}")
+            if @report_table
+              @report_table.write_stats("AUTO_INCREMENT", initial_state[:max_id] + 1)
+            else
+              PseudoCleaner::Logger.write("    ALTER TABLE #{table_name} AUTO_INCREMENT = #{initial_state[:max_id] + 1}")
+            end
           end
 
           PseudoCleaner::Configuration.db_connection(:sequel)["ALTER TABLE #{table_name} AUTO_INCREMENT = #{initial_state[:max_id] + 1}"].first
@@ -577,7 +701,7 @@ module PseudoCleaner
       elsif initial_state[:updated]
         dataset = sequel_model_table.
             unfiltered.
-            where("`#{initial_state[:updated][:column_name]}` > ?", initial_state[:created][:value])
+            where("`#{initial_state[:updated][:column_name]}` > ?", initial_state[:updated][:value])
       elsif initial_state[:count]
         dataset = sequel_model_table.unfiltered.limit(99, initial_state[:count])
       end
@@ -588,5 +712,37 @@ module PseudoCleaner
         end
       end
     end
+
+    def peek_values
+      row_data  = []
+      peek_name = nil
+
+      review_rows do |table_name, table_values|
+        peek_name = table_name
+        row_data << table_values
+      end
+
+      if row_data && !row_data.empty?
+        output_values = false
+
+        if PseudoCleaner::MasterCleaner.report_table
+          Cornucopia::Util::ReportTable.new(nested_table:         PseudoCleaner::MasterCleaner.report_table,
+                                            nested_table_label:   peek_name,
+                                            suppress_blank_table: true) do |report_table|
+            row_data.each_with_index do |row, row_index|
+              report_table.write_stats row_index.to_s, row
+            end
+          end
+        else
+          PseudoCleaner::Logger.write("  #{peek_name}")
+
+          row_data.each do |updated_value|
+            PseudoCleaner::Logger.write("    #{updated_value}")
+          end
+        end
+
+        PseudoCleaner::MasterCleaner.report_error
+      end
+    end
   end
 end