test_data 0.0.1 → 0.2.1

data/lib/test_data/generator_support.rb

@@ -0,0 +1,3 @@
+module TestData
+  BEFORE_TEST_STANZA_REGEX = /^$\n(?:^\#.*\n)*^test:/
+end

data/lib/test_data/inserts_test_data.rb

@@ -0,0 +1,25 @@
+module TestData
+  class InsertsTestData
+    def initialize
+      @config = TestData.config
+      @statistics = TestData.statistics
+    end
+
+    def call
+      search_path = connection.execute("show search_path").first["search_path"]
+      connection.disable_referential_integrity do
+        connection.execute(File.read(@config.data_dump_full_path))
+      end
+      connection.execute <<~SQL
+        select pg_catalog.set_config('search_path', '#{search_path}', false)
+      SQL
+      @statistics.count_load!
+    end
+
+    private
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+  end
+end

data/lib/test_data/loads_database_dumps.rb

@@ -16,17 +16,17 @@ module TestData
       )
 
       load_dump(
-        name: "test data",
+        name: "non-test data",
         database_name: @config.database_name,
-        relative_path: @config.data_dump_path,
-        full_path: @config.data_dump_full_path
+        relative_path: @config.non_test_data_dump_path,
+        full_path: @config.non_test_data_dump_full_path
       )
 
       load_dump(
-        name: "non-test data",
+        name: "test data",
         database_name: @config.database_name,
-        relative_path: @config.non_test_data_dump_path,
-        full_path: @config.non_test_data_dump_full_path
+        relative_path: @config.data_dump_path,
+        full_path: @config.data_dump_full_path
       )
     end
 
@@ -36,9 +36,9 @@ module TestData
       dump_pathname = Pathname.new(full_path)
       FileUtils.mkdir_p(File.dirname(dump_pathname))
       if system "psql -q -d #{database_name} < #{dump_pathname}"
-        puts "Loaded #{name} from '#{relative_path}' into database '#{database_name}' "
+        TestData.log.info "Loaded #{name} from '#{relative_path}' into database '#{database_name}' "
       else
-        raise "Failed while attempting to load #{name} from '#{relative_path}' into database '#{database_name}'"
+        raise Error.new("Failed while attempting to load #{name} from '#{relative_path}' into database '#{database_name}'")
       end
     end
   end

data/lib/test_data/log.rb

@@ -0,0 +1,76 @@
+module TestData
+  def self.log
+    @log ||= Log.new
+  end
+
+  class Log
+    LEVELS = [:debug, :info, :warn, :error, :quiet]
+    DEFAULT_WRITER = ->(message, level) do
+      output = "[test_data:#{level}] #{message}"
+      if [:warn, :error].include?(level)
+        warn output
+      else
+        puts output
+      end
+    end
+    PLAIN_WRITER = ->(message, level) do
+      if [:warn, :error].include?(level)
+        warn message
+      else
+        puts message
+      end
+    end
+
+    attr_reader :level, :writer
+
+    def initialize
+      reset
+    end
+
+    LEVELS[0...4].each do |level|
+      define_method level.to_s do |message|
+        next unless message.strip.present?
+
+        @writer.call(message, level) if enabled?(level)
+      end
+    end
+
+    def reset
+      self.level = ENV["TEST_DATA_LOG_LEVEL"]&.to_sym || :info
+      @writer = DEFAULT_WRITER
+    end
+
+    def level=(level)
+      if LEVELS.include?(level)
+        @level = level
+      else
+        raise Error.new("Not a valid level")
+      end
+    end
+
+    def writer=(writer)
+      if writer.respond_to?(:call)
+        @writer = writer
+      else
+        raise Error.new("Log writer must be callable")
+      end
+    end
+
+    def with_writer(writer, &blk)
+      og_writer = self.writer
+      self.writer = writer
+      blk.call
+      self.writer = og_writer
+    end
+
+    def with_plain_writer(&blk)
+      with_writer(PLAIN_WRITER, &blk)
+    end
+
+    private
+
+    def enabled?(level)
+      LEVELS.index(level) >= LEVELS.index(@level)
+    end
+  end
+end

data/lib/test_data/manager.rb

@@ -0,0 +1,187 @@
+module TestData
+  class Manager
+    def initialize
+      @inserts_test_data = InsertsTestData.new
+      @truncates_test_data = TruncatesTestData.new
+      @config = TestData.config
+      @statistics = TestData.statistics
+      @save_points = []
+    end
+
+    def load
+      ensure_after_load_save_point_is_active_if_data_is_loaded!
+      return rollback_to_after_data_load if save_point_active?(:after_data_load)
+
+      create_save_point(:before_data_load)
+      @inserts_test_data.call
+      @config.after_test_data_load_hook.call
+      record_ar_internal_metadata_that_test_data_is_loaded
+      create_save_point(:after_data_load)
+    end
+
+    def truncate
+      ensure_after_load_save_point_is_active_if_data_is_loaded!
+      ensure_after_truncate_save_point_is_active_if_data_is_truncated!
+      return rollback_to_after_data_truncate if save_point_active?(:after_data_truncate)
+
+      if save_point_active?(:after_data_load)
+        # If a test that uses the test data runs before a test that starts by
+        # calling truncate, tables in the database that would NOT be truncated
+        # may have been changed. To avoid this category of test pollution, start
+        # the truncation by rolling back to the known clean point
+        rollback_to_after_data_load
+      else
+        # Seems silly loading data when the user asked us to truncate, but
+        # it's important that the state of the transaction stack matches the
+        # mental model we advertise, because any _other_ test in their suite
+        # should expect that the existence of :after_data_truncate save point
+        # implies that it's safe to rollback to the :after_data_load save
+        # point; since tests run in random order, it's likely to happen
+        TestData.log.debug("TestData.uses_clean_slate was called, but data was not loaded. Loading data before truncate to preserve the transaction save point ordering")
+        load
+      end
+
+      @truncates_test_data.call
+      @config.after_test_data_truncate_hook.call
+      record_ar_internal_metadata_that_test_data_is_truncated
+      create_save_point(:after_data_truncate)
+    end
+
+    def load_custom_data(loader, **options)
+      loader.validate!(**options)
+      snapshot_name = "user_#{loader.name}".to_sym
+
+      ensure_after_load_save_point_is_active_if_data_is_loaded!
+      ensure_after_truncate_save_point_is_active_if_data_is_truncated!
+      ensure_custom_save_point_is_active_if_memo_exists!(snapshot_name)
+
+      loader.load_requested(**options)
+      if save_point_active?(snapshot_name) && loader.loaded?(**options)
+        return rollback_to_custom_savepoint(snapshot_name)
+      end
+
+      if save_point_active?(:after_data_truncate)
+        rollback_to_after_data_truncate
+      else
+        truncate
+      end
+
+      loader.load(**options)
+      record_ar_internal_metadata_of_custom_save_point(snapshot_name)
+      create_save_point(snapshot_name)
+    end
+
+    def rollback_to_before_data_load
+      if save_point_active?(:before_data_load)
+        rollback_save_point(:before_data_load)
+        # No need to recreate the save point
+        # (TestData.uses_test_data will if called)
+      end
+    end
+
+    private
+
+    def rollback_to_after_data_load
+      if save_point_active?(:after_data_load)
+        rollback_save_point(:after_data_load)
+        create_save_point(:after_data_load)
+      end
+    end
+
+    def rollback_to_after_data_truncate
+      if save_point_active?(:after_data_truncate)
+        rollback_save_point(:after_data_truncate)
+        create_save_point(:after_data_truncate)
+      end
+    end
+
+    def rollback_to_custom_savepoint(name)
+      if save_point_active?(name)
+        rollback_save_point(name)
+        create_save_point(name)
+      end
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def ensure_after_load_save_point_is_active_if_data_is_loaded!
+      if !save_point_active?(:after_data_load) && ar_internal_metadata_shows_test_data_is_loaded?
+        TestData.log.debug "Test data appears to be loaded, but the :after_data_load save point was rolled back (and not by this gem). Recreating the :after_data_load save point"
+        create_save_point(:after_data_load)
+      end
+    end
+
+    def record_ar_internal_metadata_that_test_data_is_loaded
+      if ar_internal_metadata_shows_test_data_is_loaded?
+        TestData.log.warn "Attempted to record that test data is loaded in ar_internal_metadata, but record already existed. Perhaps a previous test run committed your test data?"
+      else
+        ActiveRecord::InternalMetadata.create!(key: "test_data:loaded", value: "true")
+      end
+    end
+
+    def ar_internal_metadata_shows_test_data_is_loaded?
+      ActiveRecord::InternalMetadata.find_by(key: "test_data:loaded")&.value == "true"
+    end
+
+    def ensure_after_truncate_save_point_is_active_if_data_is_truncated!
+      if !save_point_active?(:after_data_truncate) && ar_internal_metadata_shows_test_data_is_truncated?
+        TestData.log.debug "Test data appears to be loaded, but the :after_data_truncate save point was rolled back (and not by this gem). Recreating the :after_data_truncate save point"
+        create_save_point(:after_data_truncate)
+      end
+    end
+
+    def record_ar_internal_metadata_that_test_data_is_truncated
+      if ar_internal_metadata_shows_test_data_is_truncated?
+        TestData.log.warn "Attempted to record that test data is truncated in ar_internal_metadata, but record already existed. Perhaps a previous test run committed the truncation of your test data?"
+      else
+        ActiveRecord::InternalMetadata.create!(key: "test_data:truncated", value: "true")
+      end
+    end
+
+    def ar_internal_metadata_shows_test_data_is_truncated?
+      ActiveRecord::InternalMetadata.find_by(key: "test_data:truncated")&.value == "true"
+    end
+
+    def ensure_custom_save_point_is_active_if_memo_exists!(name)
+      if !save_point_active?(name) && ar_internal_metadata_shows_custom_operation_was_persisted?(name)
+        TestData.log.debug "#{name} appears to have been loaded by test_data, but the #{name} save point was rolled back (and not by this gem). Recreating the #{name} save point"
+        create_save_point(name)
+      end
+    end
+
+    def ar_internal_metadata_shows_custom_operation_was_persisted?(name)
+      ActiveRecord::InternalMetadata.find_by(key: "test_data:#{name}")&.value == "true"
+    end
+
+    def record_ar_internal_metadata_of_custom_save_point(name)
+      if ar_internal_metadata_shows_custom_operation_was_persisted?(name)
+        TestData.log.warn "Attempted to record that test_data had loaded #{name} in ar_internal_metadata, but record already existed. Perhaps a previous test run committed it?"
+      else
+        ActiveRecord::InternalMetadata.create!(key: "test_data:#{name}", value: "true")
+      end
+    end
+
+    def save_point_active?(name)
+      purge_closed_save_points!
+      !!@save_points.find { |sp| sp.name == name }&.active?
+    end
+
+    def create_save_point(name)
+      raise Error.new("Could not create test_data savepoint '#{name}', because it was already active!") if save_point_active?(name)
+      @save_points << SavePoint.new(name)
+    end
+
+    def rollback_save_point(name)
+      @save_points.find { |sp| sp.name == name }&.rollback!
+      purge_closed_save_points!
+    end
+
+    def purge_closed_save_points!
+      @save_points = @save_points.select { |save_point|
+        save_point.active?
+      }
+    end
+  end
+end

data/lib/test_data/rake.rb

@@ -22,13 +22,15 @@ end
 
 desc "Verifies test_data environment looks good"
 task "test_data:verify_config" do
-  config = TestData::VerifiesConfiguration.new.call
-  unless config.looks_good?
-    puts "The test_data gem is not configured correctly. Try 'rake test_data:install'?\n"
-    config.problems.each do |problem|
-      puts "  - #{problem}"
+  TestData.log.with_plain_writer do
+    config = TestData::VerifiesConfiguration.new.call
+    unless config.looks_good?
+      TestData.log.warn "\nThe test_data gem is not configured correctly. Try running: rake test_data:configure\n\n"
+      config.problems.each do |problem|
+        TestData.log.warn "  - #{problem}"
+      end
+      fail
     end
-    fail
   end
 end
 
@@ -48,17 +50,26 @@ task "test_data:initialize" => ["test_data:verify_config", :environment] do
     ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord::Base.schema_format, ENV["SCHEMA"], "test_data")
     ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
+
+  TestData.log.info <<~MSG
+    Your test_data environment and database are ready for use! You can now run your server (or any command) to create some test data like so:
+
+      $ RAILS_ENV=test_data bin/rails server
+
+  MSG
 end
 
 desc "Initialize test_data Rails environment & configure database"
 task "test_data:install" => ["test_data:configure", "test_data:initialize"]
 
 desc "Dumps the interactive test_data database"
-task "test_data:dump" => "test_data:verify_config" do
+task "test_data:dump" => ["test_data:verify_config", :environment] do
+  next run_in_test_data_env("test_data:dump") if wrong_env?
+
   TestData::DumpsDatabase.new.call
 end
 
-desc "Dumps the interactive test_data database"
+desc "Loads the schema and data SQL dumps into the test_data database"
 task "test_data:load" => ["test_data:verify_config", :environment] do
   next run_in_test_data_env("test_data:load") if wrong_env?
 
@@ -71,7 +82,7 @@ task "test_data:load" => ["test_data:verify_config", :environment] do
   TestData::LoadsDatabaseDumps.new.call
 
   if ActiveRecord::Base.connection.migration_context.needs_migration?
-    warn "Warning: There are pending migrations for database '#{TestData.config.database_name}'. To run them, run:\n\n  RAILS_ENV=test_data bin/rake db:migrate\n\n"
+    TestData.log.warn "There are pending migrations for database '#{TestData.config.database_name}'. To run them, run:\n\n  $ RAILS_ENV=test_data bin/rake db:migrate\n\n"
   end
 end
 

data/lib/test_data/save_point.rb

@@ -0,0 +1,34 @@
+module TestData
+  class SavePoint
+    attr_reader :name, :transaction
+
+    def initialize(name)
+      @name = name
+      @transaction = connection.begin_transaction(joinable: false, _lazy: false)
+    end
+
+    def active?
+      !@transaction.state.finalized?
+    end
+
+    def rollback!
+      warn_if_not_rollbackable!
+      while active?
+        connection.rollback_transaction
+      end
+    end
+
+    private
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def warn_if_not_rollbackable!
+      return if active?
+      TestData.log.warn(
+        "Attempted to roll back transaction save point '#{name}', but its state was #{@transaction.state}"
+      )
+    end
+  end
+end

data/lib/test_data/statistics.rb

@@ -0,0 +1,31 @@
+module TestData
+  def self.statistics
+    @statistics ||= Statistics.new
+  end
+
+  class Statistics
+    attr_reader :load_count, :truncate_count, :load_rails_fixtures_count
+
+    def initialize
+      reset
+    end
+
+    def count_load!
+      @load_count += 1
+    end
+
+    def count_truncate!
+      @truncate_count += 1
+    end
+
+    def count_load_rails_fixtures!
+      @load_rails_fixtures_count += 1
+    end
+
+    def reset
+      @load_count = 0
+      @truncate_count = 0
+      @load_rails_fixtures_count = 0
+    end
+  end
+end