test_data 0.1.0 → 0.2.0

data/example/spec/requests/boops_spec.rb

@@ -2,11 +2,7 @@ require "rails_helper"
 
 RSpec.configure do |config|
   config.before(:each) do
-    TestData.load
-  end
-
-  config.after(:each) do
-    TestData.rollback
+    TestData.uses_test_data
   end
 end
 

data/example/spec/requests/rails_fixtures_override_spec.rb

@@ -0,0 +1,84 @@
+require "rails_helper"
+
+TestData.prevent_rails_fixtures_from_loading_automatically!
+
+RSpec.describe "FixtureFreeTestData", type: :request do
+  fixtures :boops
+
+  before(:each) do
+    TestData.uses_test_data
+  end
+
+  it "has 15 boops in the test_data" do
+    expect(Boop.count).to eq(15)
+  end
+end
+
+RSpec.describe "FixturesUsingTest", type: :request do
+  fixtures :boops
+
+  before(:each) do
+    TestData.uses_rails_fixtures(self)
+  end
+
+  it "has_fixture_boops" do
+    expect(boops(:boop_1)).to be_persisted
+    expect(Boop.count).to eq(2)
+  end
+
+  it "does_not_get_the_other_fixture_accessor" do
+    expect { method(:pants) }.to raise_error(NameError)
+  end
+
+  it "even_explicitly_loading_test_data_will_truncate_and_then_load_fixtures" do
+    TestData.uses_test_data
+    TestData.uses_rails_fixtures(self)
+
+    expect(Boop.count).to eq(2)
+  end
+
+  it "load_and_rollback_leaves_them_as_is" do
+    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)
+
+    expect(Boop.find(boop.id).created_at.to_date).to eq(a_year_ago)
+
+    # Now after rollback
+    TestData.uses_rails_fixtures(self)
+
+    expect(Boop.find(boop.id).created_at.to_date).to eq(original_created_on)
+  end
+end
+
+RSpec.describe "SomeFixturesAndSomeTestDataInOneClassTest", type: :request do
+  fixtures :all
+
+  it "fixtures_work" do
+    TestData.uses_rails_fixtures(self)
+
+    expect(boops(:boop_1).updated_at.to_date).to eq(Date.civil(2020, 1, 1))
+    expect(pants(:pant_1).brand).to eq("Levi")
+  end
+
+  it "test_that_rewinds_to_test_data" do
+    TestData.uses_test_data
+
+    expect(Boop.count).to eq(15)
+  end
+
+  it "that_rewinds_to_the_very_start" do
+    TestData.uninitialize
+
+    expect(Boop.count).to eq(0)
+  end
+
+  it "fixtures_get_reloaded_because_cache_is_cleared" do
+    TestData.uses_rails_fixtures(self)
+
+    expect(boops(:boop_2).updated_at.to_date).to eq(Date.civil(2019, 1, 1))
+    expect(pants(:pant_2).brand).to eq("Wrangler")
+  end
+end

data/example/test/integration/better_mode_switching_demo_test.rb

@@ -8,19 +8,11 @@ class ActiveSupport::TestCase
       include FactoryBot::Syntax::Methods
 
       setup do
-        TestData.truncate
-      end
-
-      teardown do
-        TestData.rollback(:after_data_truncate)
+        TestData.uses_clean_slate
       end
     when :test_data
       setup do
-        TestData.load
-      end
-
-      teardown do
-        TestData.rollback
+        TestData.uses_test_data
       end
     end
   end

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

@@ -6,11 +6,7 @@ class ParallelizedTransactionalFixturefullTestCase < ActiveSupport::TestCase
   fixtures :all
 
   setup do
-    TestData.load
-  end
-
-  teardown do
-    TestData.rollback
+    TestData.uses_test_data
   end
 end
 

data/example/test/integration/parallel_boops_without_fixtures_test.rb

@@ -5,11 +5,7 @@ class ParallelizedNonTransactionalFixturelessTestCase < ActiveSupport::TestCase
   self.use_transactional_tests = false
 
   setup do
-    TestData.load
-  end
-
-  teardown do
-    TestData.rollback
+    TestData.uses_test_data
   end
 end
 

data/example/test/integration/rails_fixtures_double_load_test.rb

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

@@ -6,26 +6,23 @@ class FixtureFreeTestData < ActiveSupport::TestCase
   fixtures :boops # why not
 
   setup do
-    TestData.load
+    TestData.uses_test_data
   end
 
   def test_has_no_fixture_boops
     assert_equal 15, Boop.count
   end
-
-  teardown do
-    TestData.rollback
-  end
 end
 
 class FixturesUsingTest < ActiveSupport::TestCase
   fixtures :boops
 
   setup do
-    TestData.load_rails_fixtures(self)
+    TestData.uses_rails_fixtures(self)
   end
 
   def test_has_fixture_boops
+    assert boops(:boop_1).persisted?
     assert_equal 2, Boop.count
   end
 
@@ -34,29 +31,25 @@ class FixturesUsingTest < ActiveSupport::TestCase
   end
 
   def test_even_explicitly_loading_test_data_will_truncate_and_then_load_fixtures
-    TestData.load
-    TestData.load_rails_fixtures(self)
+    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_at_time = boop.created_at
-    a_year_ago = 1.year.ago
+    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, a_year_ago
+    assert_equal Boop.find(boop.id).created_at.to_date, a_year_ago
 
-    # Now after rollback
-    TestData.rollback(:after_load_rails_fixtures)
+    # Now trigger a rollback to the fixtures point
+    TestData.uses_rails_fixtures(self)
 
-    assert_equal Boop.find(boop.id).created_at, original_created_at_time
-  end
-
-  teardown do
-    TestData.rollback(:after_load_rails_fixtures)
+    assert_equal Boop.find(boop.id).created_at.to_date, original_created_on
   end
 end
 
@@ -65,35 +58,29 @@ class SomeFixturesAndSomeTestDataInOneClassTest < ActiveSupport::TestCase
   fixtures :all
 
   def test_fixtures_work
-    TestData.load_rails_fixtures(self)
+    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
-
-    TestData.rollback(:after_load_rails_fixtures)
   end
 
   def test_that_rewinds_to_test_data
-    TestData.load
+    TestData.uses_test_data
 
     assert_equal 15, Boop.count
-
-    TestData.rollback
   end
 
   def test_that_rewinds_to_the_very_start
-    TestData.rollback(:before_data_load)
+    TestData.uninitialize
 
     assert_equal 0, Boop.count
   end
 
   def test_fixtures_get_reloaded_because_cache_is_cleared
-    TestData.load_rails_fixtures(self)
+    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
-
-    TestData.rollback(:after_load_rails_fixtures)
   end
 end
 
@@ -101,11 +88,7 @@ class PantsFixturesTest < ActiveSupport::TestCase
   fixtures :pants
 
   setup do
-    TestData.load_rails_fixtures(self)
-  end
-
-  teardown do
-    TestData.rollback(:after_load_rails_fixtures)
+    TestData.uses_rails_fixtures(self)
   end
 
   def test_has_fixture_pants
@@ -120,8 +103,8 @@ end
 class FixtureTestPassingTheWrongThingTest < ActiveSupport::TestCase
   def test_doing_it_wrong
     error = assert_raises(TestData::Error) do
-      TestData.load_rails_fixtures(ActiveRecord::Base)
+      TestData.uses_rails_fixtures(ActiveRecord::Base)
     end
-    assert_match "'TestData.load_rails_fixtures' must be passed a test instance that has had ActiveRecord::TestFixtures mixed-in (e.g. `TestData.load_rails_fixtures(self)` in an ActiveSupport::TestCase `setup` block), but the provided argument does not respond to 'setup_fixtures'", error.message
+    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