test_data 0.0.2 → 0.2.2

data/example/test/integration/load_rollback_truncate_test.rb

@@ -14,7 +14,6 @@ class LoadRollbackTruncateTest < ActiveSupport::TestCase
   def teardown
     TestData.log.reset
     TestData.statistics.reset
-    TestData.rollback(:before_data_load)
   end
 
   def test_loads_data_then_truncates_then_rolls_back_etc
@@ -22,101 +21,97 @@ class LoadRollbackTruncateTest < ActiveSupport::TestCase
     assert_equal 0, Boop.count
 
     # Now load the dump
-    TestData.load
+    TestData.uses_test_data
     assert_equal 15, Boop.count
     Boop.create!
     assert_equal 16, Boop.count
 
     # Next, truncate the boops
-    TestData.truncate
+    TestData.uses_clean_slate
     assert_equal 0, Boop.count
     Boop.create!
     assert_equal 1, Boop.count
 
     # Now roll back to _just after truncate_
-    TestData.rollback(:after_data_truncate)
+    TestData.uses_clean_slate
     assert_equal 0, Boop.count
     Boop.create!
     assert_equal 1, Boop.count
 
     # Verify default rollback works after truncate
-    TestData.rollback
+    TestData.uses_test_data
     assert_equal 15, Boop.count
 
     # Verify touching non-test-data tables will also be first rollbacked when truncate is called
-    TestData.rollback(:before_data_load)
+    TestData.uninitialize
     good = ChattyAuditLog.create!(message: "I do belong here, because now we're at the start, prior to test_data's purview")
-    TestData.load
+    TestData.uses_test_data
     bad = ChattyAuditLog.create!(message: "I won't belong here after truncate because I'm data that the truncate-calling test wouldn't expect")
     assert_equal 2, ChattyAuditLog.count
 
-    TestData.truncate
+    TestData.uses_clean_slate
 
     assert_equal 1, ChattyAuditLog.count
     refute_nil ChattyAuditLog.find_by(id: good.id)
     assert_nil ChattyAuditLog.find_by(id: bad.id)
 
-    # Verify rollbacking to some nonsense savepoint errors out:
-    error = assert_raise(TestData::Error) { TestData.rollback(:before_nonsense) }
-    assert_match "No known save point named 'before_nonsense'", error.message
-
     # Warn but load anyway if rolled back to the start and then truncated
-    TestData.rollback(:before_data_load)
-    TestData.truncate
+    TestData.uninitialize
+    TestData.uses_clean_slate
     assert_equal :debug, @last_log.level
-    assert_match "TestData.truncate was called, but data was not loaded. Loading data", @last_log.message
+    assert_match "TestData.uses_clean_slate was called, but data was not loaded. Loading data", @last_log.message
     assert_equal 0, Boop.count
-    TestData.rollback
+    TestData.uses_test_data
     assert_equal 15, Boop.count
 
     # Chaos: try rolling back outside the gem (one level of extraneous rollback) and verify load recovers
-    TestData.rollback(:before_data_load)
+    TestData.uninitialize
     TestData.statistics.reset
     assert_equal 0, TestData.statistics.load_count
-    TestData.load
+    TestData.uses_test_data
     assert_equal 1, TestData.statistics.load_count
-    TestData.load # Smart enough to not load again
+    TestData.uses_test_data # Smart enough to not load again
     assert_equal 1, TestData.statistics.load_count
     ActiveRecord::Base.connection.rollback_transaction # Someone might do this!
-    TestData.load # Still smart enough to not do this
+    TestData.uses_test_data # Still smart enough to not do this
     assert_equal 1, TestData.statistics.load_count
-    TestData.rollback # after load savepoint should have been healed with subsequent load call
+    TestData.uses_test_data # after load savepoint should have been healed with subsequent load call
     assert_equal 15, Boop.count
 
     # Chaos: try rolling back outside the gem (one level of extraneous rollback) and verify truncate recovers
-    TestData.rollback(:before_data_load)
+    TestData.uninitialize
     TestData.statistics.reset
     assert_equal 0, TestData.statistics.truncate_count
-    TestData.load
-    TestData.truncate
+    TestData.uses_test_data
+    TestData.uses_clean_slate
     assert_equal 1, TestData.statistics.truncate_count
-    TestData.truncate
+    TestData.uses_clean_slate
     assert_equal 1, TestData.statistics.truncate_count
     ActiveRecord::Base.connection.rollback_transaction # Someone might do this!
-    TestData.truncate # Will recover, not take the bait
+    TestData.uses_clean_slate # Will recover, not take the bait
     assert_equal 1, TestData.statistics.truncate_count
-    TestData.rollback(:after_data_truncate) # after truncate savepoint should have been healed with subsequent truncate call
+    TestData.uses_clean_slate # after truncate savepoint should have been healed with subsequent truncate call
     assert_equal 0, Boop.count
-    TestData.rollback
+    TestData.uses_test_data
     assert_equal 15, Boop.count
 
     # Chaos: load data then call rollback two times and ensure we're still in a good spot
-    TestData.rollback(:before_data_load)
+    TestData.uninitialize
     TestData.statistics.reset
-    TestData.load
+    TestData.uses_test_data
     assert_equal 15, Boop.count
     2.times do # Two rollbacks means we're back at before_data_load
       ActiveRecord::Base.connection.rollback_transaction
     end
     assert_equal 0, Boop.count
-    TestData.load # It should successfully load again a second time
+    TestData.uses_test_data # It should successfully load again a second time
     assert_equal 15, Boop.count
     assert_equal 2, TestData.statistics.load_count
 
     # Chaos: truncate data then call rollback two times and ensure we're still in a good spot
-    TestData.rollback(:before_data_load)
+    TestData.uninitialize
     TestData.statistics.reset
-    TestData.truncate # will warn-and-load and then truncate
+    TestData.uses_clean_slate # will warn-and-load and then truncate
     assert_equal 0, Boop.count
     2.times do # Two rollbacks means data is loaded but after_data_load savepoint has been lost
       ActiveRecord::Base.connection.rollback_transaction
@@ -124,14 +119,14 @@ class LoadRollbackTruncateTest < ActiveSupport::TestCase
     assert_equal 15, Boop.count
     assert_equal 1, TestData.statistics.load_count
     assert_equal 1, TestData.statistics.truncate_count
-    TestData.truncate # should restore the lost after_data_load savepoint and re-truncate
+    TestData.uses_clean_slate # should restore the lost after_data_load savepoint and re-truncate
     3.times do # Three rollbacks means we are at before_data_load again
       ActiveRecord::Base.connection.rollback_transaction
     end
     assert_equal 0, Boop.count
-    TestData.load
+    TestData.uses_test_data
     assert_equal 15, Boop.count
-    TestData.truncate
+    TestData.uses_clean_slate
     assert_equal 0, Boop.count
     assert_equal 3, TestData.statistics.truncate_count
     assert_equal 2, TestData.statistics.load_count
@@ -140,17 +135,15 @@ class LoadRollbackTruncateTest < ActiveSupport::TestCase
   def test_suite_runs_different_tests_in_whatever_order
     # Imagine a test-datay test runs
     test_data_using_test = -> do
-      TestData.load # before each
+      TestData.uses_test_data # before each
       Boop.create!
       assert_equal 16, Boop.count
-      TestData.rollback # after each
     end
 
     test_data_avoiding_test = -> do
-      TestData.truncate # before each
+      TestData.uses_clean_slate # before each
       Boop.create!
       assert_equal 1, Boop.count
-      TestData.rollback(:after_data_truncate) # after each
     end
 
     # Run the tests separately:
@@ -170,23 +163,25 @@ class LoadRollbackTruncateTest < ActiveSupport::TestCase
     # In the interest of behaving similarly to .load, rollback in case the
     # previous test doesn't have an after_each as you might hope/expect
     3.times do
-      TestData.truncate
+      TestData.uses_clean_slate
       Boop.create!
       assert_equal 1, Boop.count
     end
   end
 
   def test_other_rollbacks_mess_with_transaction_state_will_debug_you
-    TestData.load
+    TestData.uninitialize
+    TestData.statistics.reset
+    TestData.uses_test_data
     ActiveRecord::Base.connection.rollback_transaction # data loaded, after_data_load save point destroyed
-    TestData.load
+    TestData.uses_test_data
     assert_equal :debug, @last_log.level # debug only b/c rails fixtures will do this on every after_each if enabled
     assert_match "Recreating the :after_data_load save point", @last_log.message
     assert_equal 1, TestData.statistics.load_count
 
-    TestData.truncate
+    TestData.uses_clean_slate
     ActiveRecord::Base.connection.rollback_transaction # data loaded, after_data_truncate save point destroyed
-    TestData.truncate
+    TestData.uses_clean_slate
     assert_equal :debug, @last_log.level # debug only b/c rails fixtures will do this on every after_each if enabled
     assert_match "Recreating the :after_data_truncate save point", @last_log.message
     assert_equal 1, TestData.statistics.load_count

data/example/test/integration/mode_switching_demo_test.rb

@@ -1,29 +1,19 @@
 require "test_helper"
 
 class ModeSwitchingTestCase < ActiveSupport::TestCase
+  self.use_transactional_tests = false
+
   def self.test_data_mode(mode)
     if mode == :factory_bot
       require "factory_bot_rails"
       include FactoryBot::Syntax::Methods
 
       setup do
-        TestData.rollback(:before_data_load)
-        ActiveRecord::Base.connection.begin_transaction(joinable: false, _lazy: false)
-      end
-
-      teardown do
-        ActiveRecord::Base.connection.rollback_transaction
+        TestData.uses_clean_slate
       end
-
     elsif mode == :test_data
-      self.use_transactional_tests = false
-
       setup do
-        TestData.load
-      end
-
-      teardown do
-        TestData.rollback
+        TestData.uses_test_data
       end
     end
   end

data/example/test/integration/parallel_boops_with_fixtures_test.rb

@@ -5,12 +5,8 @@ class ParallelizedTransactionalFixturefullTestCase < ActiveSupport::TestCase
   self.use_transactional_tests = true
   fixtures :all
 
-  def setup
-    TestData.load
-  end
-
-  def teardown
-    TestData.rollback
+  setup do
+    TestData.uses_test_data
   end
 end
 

data/example/test/integration/parallel_boops_without_fixtures_test.rb

@@ -4,12 +4,8 @@ class ParallelizedNonTransactionalFixturelessTestCase < ActiveSupport::TestCase
   parallelize(workers: :number_of_processors)
   self.use_transactional_tests = false
 
-  def setup
-    TestData.load
-  end
-
-  def teardown
-    TestData.rollback
+  setup do
+    TestData.uses_test_data
   end
 end
 

data/example/test/integration/rails_fixtures_double_load_test.rb

@@ -0,0 +1,10 @@
+require "test_helper"
+
+class FixturesUsingTest < ActiveSupport::TestCase
+  def test_tries_to_load_rails_fixtures_with_test_data
+    error = assert_raises(TestData::Error) do
+      TestData.uses_rails_fixtures(self)
+    end
+    assert_match "'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", error.message
+  end
+end

data/example/test/integration/rails_fixtures_override_test.rb

@@ -0,0 +1,110 @@
+require "test_helper"
+
+TestData.prevent_rails_fixtures_from_loading_automatically!
+
+class FixtureFreeTestData < ActiveSupport::TestCase
+  fixtures :boops # why not
+
+  setup do
+    TestData.uses_test_data
+  end
+
+  def test_has_no_fixture_boops
+    assert_equal 15, Boop.count
+  end
+end
+
+class FixturesUsingTest < ActiveSupport::TestCase
+  fixtures :boops
+
+  setup do
+    TestData.uses_rails_fixtures(self)
+  end
+
+  def test_has_fixture_boops
+    assert boops(:boop_1).persisted?
+    assert_equal 2, Boop.count
+  end
+
+  def test_does_not_get_the_other_fixture_accessor
+    assert_raises(NameError) { method(:pants) }
+  end
+
+  def test_even_explicitly_loading_test_data_will_truncate_and_then_load_fixtures
+    TestData.uses_test_data
+    TestData.uses_rails_fixtures(self)
+
+    assert_equal 2, Boop.count
+  end
+
+  def test_load_and_rollback_leaves_them_as_is
+    boop = Boop.first
+    original_created_on = boop.created_at.to_date
+    a_year_ago = 1.year.ago.to_date
+
+    boop.update!(created_at: a_year_ago)
+
+    assert_equal Boop.find(boop.id).created_at.to_date, a_year_ago
+
+    # Now trigger a rollback to the fixtures point
+    TestData.uses_rails_fixtures(self)
+
+    assert_equal Boop.find(boop.id).created_at.to_date, original_created_on
+  end
+end
+
+class SomeFixturesAndSomeTestDataInOneClassTest < ActiveSupport::TestCase
+  i_suck_and_my_tests_are_order_dependent!
+  fixtures :all
+
+  def test_fixtures_work
+    TestData.uses_rails_fixtures(self)
+
+    assert_equal Date.civil(2020, 1, 1), boops(:boop_1).updated_at.to_date
+    assert_equal "Levi", pants(:pant_1).brand
+  end
+
+  def test_that_rewinds_to_test_data
+    TestData.uses_test_data
+
+    assert_equal 15, Boop.count
+  end
+
+  def test_that_rewinds_to_the_very_start
+    TestData.uninitialize
+
+    assert_equal 0, Boop.count
+  end
+
+  def test_fixtures_get_reloaded_because_cache_is_cleared
+    TestData.uses_rails_fixtures(self)
+
+    assert_equal Date.civil(2019, 1, 1), boops(:boop_2).updated_at.to_date
+    assert_equal "Wrangler", pants(:pant_2).brand
+  end
+end
+
+class PantsFixturesTest < ActiveSupport::TestCase
+  fixtures :pants
+
+  setup do
+    TestData.uses_rails_fixtures(self)
+  end
+
+  def test_has_fixture_pants
+    assert_equal 2, Pant.count
+  end
+
+  def test_does_not_get_the_other_fixture_accessor
+    assert_raises(NameError) { method(:boops) }
+  end
+end
+
+class FixtureTestPassingTheWrongThingTest < ActiveSupport::TestCase
+  def test_doing_it_wrong
+    error = assert_raises(TestData::Error) do
+      TestData.uses_rails_fixtures(ActiveRecord::Base)
+    end
+    assert_match "'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'", error.message
+  end
+end

data/example/test/integration/test_data_hooks_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+TestData.config do |config|
+  config.after_test_data_load { MetaBoop.refresh_materialized_view }
+  config.after_test_data_truncate(-> { MetaBoop.refresh_materialized_view })
+  config.after_rails_fixture_load { MetaBoop.refresh_materialized_view }
+end
+
+TestData.prevent_rails_fixtures_from_loading_automatically!
+MetaBoop.refresh_materialized_view # count = 1
+
+class TestDataHooksTest < ActiveSupport::TestCase
+  fixtures :all
+  i_suck_and_my_tests_are_order_dependent!
+
+  def test_uses_test_data_hook
+    assert_equal 1, MetaBoop.refresh_materialized_view_count
+    MetaBoop.reset_refresh_materialized_view_count
+
+    # Materialized view is refreshed and called 1 time
+    TestData.uses_test_data
+    assert_equal 15, Boop.count
+    assert_equal 15, MetaBoop.count
+    assert_equal 1, MetaBoop.refresh_materialized_view_count
+    MetaBoop.reset_refresh_materialized_view_count
+
+    # Rollbacks also rollback to materialized view changes without calling again
+    Boop.create!(other_boop: Boop.new)
+    assert_equal 16, Boop.count
+    assert_equal 15, MetaBoop.count
+    MetaBoop.refresh_materialized_view
+    assert_equal 16, MetaBoop.count
+    assert_equal 1, MetaBoop.refresh_materialized_view_count
+    TestData.uses_test_data
+    assert_equal 15, Boop.count
+    assert_equal 15, MetaBoop.count
+    assert_equal 1, MetaBoop.refresh_materialized_view_count
+    MetaBoop.reset_refresh_materialized_view_count
+
+    # The same hook also works when cleaning slates
+    TestData.uses_clean_slate
+    assert_equal 0, Boop.count
+    assert_equal 0, MetaBoop.count
+    assert_equal 1, MetaBoop.refresh_materialized_view_count
+    Boop.create!(other_boop: Boop.new)
+    MetaBoop.refresh_materialized_view
+    assert_equal 1, Boop.count
+    assert_equal 1, MetaBoop.count
+    assert_equal 2, MetaBoop.refresh_materialized_view_count
+    TestData.uses_clean_slate
+    assert_equal 0, Boop.count
+    assert_equal 0, MetaBoop.count
+    assert_equal 2, MetaBoop.refresh_materialized_view_count
+    MetaBoop.reset_refresh_materialized_view_count
+
+    # The same hook works with fixtures
+    TestData.uses_rails_fixtures(self)
+    assert_equal 2, Boop.count
+    assert_equal 2, MetaBoop.count
+    assert_equal 1, MetaBoop.refresh_materialized_view_count
+    Boop.first.delete
+    assert_equal 1, Boop.count
+    assert_equal 2, MetaBoop.count
+    MetaBoop.refresh_materialized_view
+    assert_equal 1, MetaBoop.count
+    assert_equal 2, MetaBoop.refresh_materialized_view_count
+    TestData.uses_rails_fixtures(self)
+    assert_equal 2, Boop.count
+    assert_equal 2, MetaBoop.count
+    assert_equal 2, MetaBoop.refresh_materialized_view_count
+    MetaBoop.reset_refresh_materialized_view_count
+
+    # Rewinding two steps will not call refresh materialized views
+    TestData.uses_test_data
+    assert_equal 15, Boop.count
+    assert_equal 15, MetaBoop.count
+    assert_equal 0, MetaBoop.refresh_materialized_view_count
+  end
+
+  def test_that_hooks_require_valid_settings
+    foo = Struct.new(:thing)
+    assert_raises(TestData::Error) { TestData.config.after_test_data_load(nil) }
+    assert_raises(TestData::Error) { TestData.config.after_test_data_truncate(nil) }
+    assert_raises(TestData::Error) { TestData.config.after_rails_fixture_load(nil) }
+    assert_raises(TestData::Error) { TestData.config.after_test_data_load(foo) }
+    assert_raises(TestData::Error) { TestData.config.after_test_data_truncate(foo) }
+    assert_raises(TestData::Error) { TestData.config.after_rails_fixture_load(foo) }
+  end
+end