test_data 0.1.0 → 0.2.0

data/example/test/integration/transaction_committing_boops_test.rb

@@ -1,13 +1,11 @@
 require "test_helper"
 
-TestData.config.use_transactional_data_loader = false
-
 class TransactionCommittingTestCase < ActiveSupport::TestCase
   self.use_transactional_tests = false
 
   setup do
     Noncommittal.stop!
-    TestData.load
+    TestData.insert_test_data_dump
   end
 
   teardown do
@@ -26,11 +24,4 @@ class TransactionCommittingBoopsTest < TransactionCommittingTestCase
   def test_finds_the_boops_via_another_process
     assert_equal 15, `RAILS_ENV=test bin/rails runner "puts Boop.count"`.chomp.to_i
   end
-
-  def test_cant_have_it_both_ways
-    error = assert_raise(TestData::Error) do
-      TestData.config.use_transactional_data_loader = true
-    end
-    assert_match "There is already a non-transactional data loader", error.message
-  end
 end

data/example/test/test_helper.rb

@@ -9,10 +9,6 @@ class SerializedNonTransactionalTestCase < ActiveSupport::TestCase
   self.use_transactional_tests = false
 
   setup do
-    TestData.load
-  end
-
-  teardown do
-    TestData.rollback
+    TestData.uses_test_data
   end
 end

data/lib/generators/test_data/environment_file_generator.rb

@@ -9,6 +9,10 @@ module TestData
         require_relative "development"
 
         Rails.application.configure do
+          # Rails creates secret key base for only "development" and "test"
+          #   For more info, see: https://github.com/testdouble/test_data/issues/2
+          self.secrets.secret_key_base ||= Rails.application.send(:generate_development_secret)
+
           # Don't persist schema.rb or structure.sql after test_data is migrated
           config.active_record.dump_schema_after_migration = false
         end

data/lib/generators/test_data/initializer_generator.rb

@@ -24,17 +24,11 @@ module TestData
           # Tables whose data should be excluded from SQL dumps (still dumps their schema DDL)
           # config.dont_dump_these_tables = []
 
-          # Tables whose data should be truncated by TestData.truncate
+          # Tables whose data should be truncated by TestData.uses_clean_slate
           #   If left as `nil`, all tables inserted into by the SQL file at
           #   `data_dump_path` will be truncated
           # config.truncate_these_test_data_tables = nil
 
-          # Perform TestData.load and TestData.truncate inside nested
-          #   transactions for increased test isolation and speed. Setting this
-          #   to false will disable several features that depend on transactions
-          #   being used
-          # config.use_transactional_data_loader = true
-
           # Log level (valid values: [:debug, :info, :warn, :error, :quiet])
           #   Can also be set with env var TEST_DATA_LOG_LEVEL
           # config.log_level = :info

data/lib/test_data.rb

@@ -9,16 +9,20 @@ require_relative "test_data/configurators/cable_yaml"
 require_relative "test_data/configurators/database_yaml"
 require_relative "test_data/configurators/secrets_yaml"
 require_relative "test_data/configurators/webpacker_yaml"
+require_relative "test_data/custom_loaders/abstract_base"
+require_relative "test_data/custom_loaders/rails_fixtures"
 require_relative "test_data/detects_database_emptiness"
 require_relative "test_data/dumps_database"
 require_relative "test_data/error"
+require_relative "test_data/inserts_test_data"
 require_relative "test_data/installs_configuration"
 require_relative "test_data/loads_database_dumps"
 require_relative "test_data/log"
 require_relative "test_data/railtie"
 require_relative "test_data/save_point"
 require_relative "test_data/statistics"
-require_relative "test_data/transactional_data_loader"
+require_relative "test_data/manager"
+require_relative "test_data/truncates_test_data"
 require_relative "test_data/verifies_configuration"
 require_relative "test_data/verifies_dumps_are_loadable"
 require_relative "test_data/version"
@@ -28,3 +32,30 @@ require_relative "generators/test_data/cable_yaml_generator"
 require_relative "generators/test_data/database_yaml_generator"
 require_relative "generators/test_data/secrets_yaml_generator"
 require_relative "generators/test_data/webpacker_yaml_generator"
+
+module TestData
+  def self.uninitialize
+    @manager ||= Manager.new
+    @manager.rollback_to_before_data_load
+  end
+
+  def self.uses_test_data
+    @manager ||= Manager.new
+    @manager.load
+  end
+
+  def self.uses_clean_slate
+    @manager ||= Manager.new
+    @manager.truncate
+  end
+
+  def self.uses_rails_fixtures(test_instance)
+    @rails_fixtures_loader ||= CustomLoaders::RailsFixtures.new
+    @manager ||= Manager.new
+    @manager.load_custom_data(@rails_fixtures_loader, test_instance: test_instance)
+  end
+
+  def self.insert_test_data_dump
+    InsertsTestData.new.call
+  end
+end

data/lib/test_data/config.rb

@@ -29,18 +29,9 @@ module TestData
     # Tables to exclude from all dumps
     attr_accessor :dont_dump_these_tables
 
-    # Tables to truncate when TestData.truncate is called
+    # Tables to truncate when TestData.uses_clean_slate is called
     attr_accessor :truncate_these_test_data_tables
 
-    # Perform TestData.load and TestData.truncate inside nested
-    # transactions for increased test isolation and speed. Setting this to false
-    # will disable several features that depend on transactions being used
-    attr_reader :use_transactional_data_loader
-    def use_transactional_data_loader=(use_transactions)
-      TestData.ensure_we_dont_mix_transactional_and_non_transactional_data_loaders!(use_transactions)
-      @use_transactional_data_loader = use_transactions
-    end
-
     # Log level (valid values: [:debug, :info, :warn, :error, :quiet])
     def log_level
       TestData.log.level
@@ -73,7 +64,6 @@ module TestData
       @non_test_data_tables = []
       @dont_dump_these_tables = []
       @truncate_these_test_data_tables = nil
-      @use_transactional_data_loader = true
     end
 
     def database_yaml

data/lib/test_data/custom_loaders/abstract_base.rb

@@ -0,0 +1,25 @@
+module TestData
+  module CustomLoaders
+    class AbstractBase
+      def name
+        raise Error.new("#name must be defined by CustomLoader subclass")
+      end
+
+      def load_requested(**options)
+      end
+
+      def loaded?(**options)
+        # Check to see if the requested data is already loaded (if possible and
+        # detectable)
+        #
+        # Return true to prevent #load from being called, potentially avoiding an
+        # expensive operation
+        false
+      end
+
+      def load(**options)
+        raise Error.new("#load must be defined by CustomLoader subclass")
+      end
+    end
+  end
+end

data/lib/test_data/custom_loaders/rails_fixtures.rb

@@ -0,0 +1,40 @@
+module TestData
+  module CustomLoaders
+    class RailsFixtures < AbstractBase
+      def initialize
+        @statistics = TestData.statistics
+        @already_loaded_rails_fixtures = {}
+      end
+
+      def name
+        :rails_fixtures
+      end
+
+      def validate!(test_instance:)
+        if !test_instance.respond_to?(:setup_fixtures)
+          raise Error.new("'TestData.uses_rails_fixtures(self)' must be passed a test instance that has had ActiveRecord::TestFixtures mixed-in (e.g. `TestData.uses_rails_fixtures(self)` in an ActiveSupport::TestCase `setup` block), but the provided argument does not respond to 'setup_fixtures'")
+        elsif !test_instance.respond_to?(:__test_data_gem_setup_fixtures)
+          raise Error.new("'TestData.uses_rails_fixtures(self)' depends on Rails' default fixture-loading behavior being disabled by calling 'TestData.prevent_rails_fixtures_from_loading_automatically!' as early as possible (e.g. near the top of your test_helper.rb), but it looks like it was never called.")
+        end
+      end
+
+      def load_requested(test_instance:)
+        ActiveRecord::FixtureSet.reset_cache
+        test_instance.instance_variable_set(:@loaded_fixtures, @already_loaded_rails_fixtures[test_instance.class])
+        test_instance.instance_variable_set(:@fixture_cache, {})
+      end
+
+      def loaded?(test_instance:)
+        @already_loaded_rails_fixtures[test_instance.class].present?
+      end
+
+      def load(test_instance:)
+        test_instance.pre_loaded_fixtures = false
+        test_instance.use_transactional_tests = false
+        test_instance.__test_data_gem_setup_fixtures
+        @already_loaded_rails_fixtures[test_instance.class] = test_instance.instance_variable_get(:@loaded_fixtures)
+        @statistics.count_load_rails_fixtures!
+      end
+    end
+  end
+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/manager.rb

@@ -0,0 +1,185 @@
+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
+      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
+      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/truncates_test_data.rb

@@ -0,0 +1,31 @@
+module TestData
+  class TruncatesTestData
+    def initialize
+      @config = TestData.config
+      @statistics = TestData.statistics
+    end
+
+    def call
+      connection.disable_referential_integrity do
+        connection.execute("TRUNCATE TABLE #{tables_to_truncate.map { |t| connection.quote_table_name(t) }.join(", ")} #{"CASCADE" unless @config.truncate_these_test_data_tables.present?}")
+      end
+      @statistics.count_truncate!
+    end
+
+    private
+
+    def tables_to_truncate
+      if @config.truncate_these_test_data_tables.present?
+        @config.truncate_these_test_data_tables
+      else
+        @tables_to_truncate ||= IO.foreach(@config.data_dump_path).grep(/^INSERT INTO/) { |line|
+          line.match(/^INSERT INTO ([^\s]+)/)&.captures&.first
+        }.compact.uniq
+      end
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+  end
+end