Migrate applicable activesupport tests to use NotificationAssertions

Author: larouxn

activesupport/test/cache/behaviors/cache_instrumentation_behavior.rb

@@ -8,9 +8,7 @@ def test_write_multi_instrumentation
     value_2 = SecureRandom.alphanumeric
     writes = { key_1 => value_1, key_2 => value_2 }
 
-    events = with_instrumentation "write_multi" do
-      @cache.write_multi(writes)
-    end
+    events = capture_notifications("cache_write_multi.active_support") { @cache.write_multi(writes) }
 
     assert_equal %w[ cache_write_multi.active_support ], events.map(&:name)
     assert_nil events[0].payload[:super_operation]
@@ -23,7 +21,7 @@ def test_instrumentation_with_fetch_multi_as_super_operation
 
     key_2 = SecureRandom.uuid
 
-    events = with_instrumentation "read_multi" do
+    events = capture_notifications("cache_read_multi.active_support") do
       @cache.fetch_multi(key_2, key_1) { |key| key * 2 }
     end
 
@@ -35,17 +33,14 @@ def test_instrumentation_with_fetch_multi_as_super_operation
   end
 
   def test_fetch_multi_instrumentation_order_of_operations
-    operations = []
-    callback = ->(name, *) { operations << name }
-
     key_1 = SecureRandom.uuid
     key_2 = SecureRandom.uuid
 
-    ActiveSupport::Notifications.subscribed(callback, /^cache_(read_multi|write_multi)\.active_support$/) do
+    operations = capture_notifications(/^cache_(read_multi|write_multi)\.active_support$/) do
       @cache.fetch_multi(key_1, key_2) { |key| key * 2 }
     end
 
-    assert_equal %w[ cache_read_multi.active_support cache_write_multi.active_support ], operations
+    assert_equal %w[ cache_read_multi.active_support cache_write_multi.active_support ], operations.map(&:name)
   end
 
   def test_read_multi_instrumentation
@@ -54,9 +49,7 @@ def test_read_multi_instrumentation
 
     key_2 = SecureRandom.uuid
 
-    events = with_instrumentation "read_multi" do
-      @cache.read_multi(key_2, key_1)
-    end
+    events = capture_notifications("cache_read_multi.active_support") { @cache.read_multi(key_2, key_1) }
 
     assert_equal %w[ cache_read_multi.active_support ], events.map(&:name)
     assert_equal [normalized_key(key_2), normalized_key(key_1)], events[0].payload[:key]
@@ -68,9 +61,7 @@ def test_read_instrumentation
     key = SecureRandom.uuid
     @cache.write(key, SecureRandom.alphanumeric)
 
-    events = with_instrumentation "read" do
-      @cache.read(key)
-    end
+    events = capture_notifications("cache_read.active_support") { @cache.read(key) }
 
     assert_equal %w[ cache_read.active_support ], events.map(&:name)
     assert_equal normalized_key(key), events[0].payload[:key]
@@ -81,9 +72,7 @@ def test_read_instrumentation
   def test_write_instrumentation
     key = SecureRandom.uuid
 
-    events = with_instrumentation "write" do
-      @cache.write(key, SecureRandom.alphanumeric)
-    end
+    events = capture_notifications("cache_write.active_support") { @cache.write(key, SecureRandom.alphanumeric) }
 
     assert_equal %w[ cache_write.active_support ], events.map(&:name)
     assert_equal normalized_key(key), events[0].payload[:key]
@@ -94,9 +83,8 @@ def test_delete_instrumentation
     key = SecureRandom.uuid
 
     options = { namespace: "foo" }
-    events = with_instrumentation "delete" do
-      @cache.delete(key, options)
-    end
+
+    events = capture_notifications("cache_delete.active_support") { @cache.delete(key, options) }
 
     assert_equal %w[ cache_delete.active_support ], events.map(&:name)
     assert_equal normalized_key(key, options), events[0].payload[:key]
@@ -109,9 +97,8 @@ def test_delete_multi_instrumentation
     key_2 = SecureRandom.uuid
 
     options = { namespace: "foo" }
-    events = with_instrumentation "delete_multi" do
-      @cache.delete_multi([key_2, key_1], options)
-    end
+
+    events = capture_notifications("cache_delete_multi.active_support") { @cache.delete_multi([key_2, key_1], options) }
 
     assert_equal %w[ cache_delete_multi.active_support ], events.map(&:name)
     assert_equal [normalized_key(key_2, options), normalized_key(key_1, options)], events[0].payload[:key]
@@ -122,9 +109,7 @@ def test_increment_instrumentation
     key_1 = SecureRandom.uuid
     @cache.write(key_1, 0)
 
-    events = with_instrumentation "increment" do
-      @cache.increment(key_1)
-    end
+    events = capture_notifications("cache_increment.active_support") { @cache.increment(key_1) }
 
     assert_equal %w[ cache_increment.active_support ], events.map(&:name)
     assert_equal normalized_key(key_1), events[0].payload[:key]
@@ -136,27 +121,14 @@ def test_decrement_instrumentation
     key_1 = SecureRandom.uuid
     @cache.write(key_1, 0)
 
-    events = with_instrumentation "decrement" do
-      @cache.decrement(key_1)
-    end
+    events = capture_notifications("cache_decrement.active_support") { @cache.decrement(key_1) }
 
     assert_equal %w[ cache_decrement.active_support ], events.map(&:name)
     assert_equal normalized_key(key_1), events[0].payload[:key]
     assert_equal @cache.class.name, events[0].payload[:store]
   end
 
   private
-    def with_instrumentation(method)
-      event_name = "cache_#{method}.active_support"
-
-      [].tap do |events|
-        ActiveSupport::Notifications.subscribe(event_name) { |event| events << event }
-        yield
-      end
-    ensure
-      ActiveSupport::Notifications.unsubscribe event_name
-    end
-
     def normalized_key(key, options = nil)
       @cache.send(:normalize_key, key, options)
     end

activesupport/test/cache/behaviors/local_cache_behavior.rb

@@ -3,13 +3,13 @@
 module LocalCacheBehavior
   def test_instrumentation_with_local_cache
     key = SecureRandom.uuid
-    events = with_instrumentation "write" do
+    events = capture_notifications("cache_write.active_support") do
       @cache.write(key, SecureRandom.uuid)
     end
     assert_equal @cache.class.name, events[0].payload[:store]
 
     @cache.with_local_cache do
-      events = with_instrumentation "read" do
+      events = capture_notifications("cache_read.active_support") do
         @cache.read(key)
         @cache.read(key)
       end

activesupport/test/cache/stores/memory_store_test.rb

@@ -44,7 +44,7 @@ def test_cleanup_instrumentation
     size = 3
     size.times { |i| @cache.write(i.to_s, i) }
 
-    events = with_instrumentation "cleanup" do
+    events = capture_notifications("cache_cleanup.active_support") do
       @cache.cleanup
     end
 

activesupport/test/deprecation_test.rb

@@ -263,20 +263,17 @@ def initialize(label, lineno)
     @deprecator.behavior = :notify
     behavior = @deprecator.behavior.first
 
-    begin
-      events = []
-      ActiveSupport::Notifications.subscribe("deprecation.my_gem_custom") { |*args|
-        events << args.extract_options!
-      }
-
-      behavior.call("Some error!", ["call stack!"], @deprecator)
-      assert_equal 1, events.size
-      assert_equal "Some error!", events.first[:message]
-      assert_equal ["call stack!"], events.first[:callstack]
-      assert_equal "horizon", events.first[:deprecation_horizon]
-      assert_equal "MyGem::Custom", events.first[:gem_name]
-    ensure
-      ActiveSupport::Notifications.unsubscribe("deprecation.my_gem_custom")
+    expected_payload = {
+      message: "Some error!",
+      callstack: ["call stack!"],
+      deprecation_horizon: "horizon",
+      gem_name: "MyGem::Custom"
+    }
+
+    assert_notifications_count("deprecation.my_gem_custom", 1) do
+      assert_notification("deprecation.my_gem_custom", expected_payload) do
+        behavior.call("Some error!", ["call stack!"], @deprecator)
+      end
     end
   end
 

activesupport/test/messages/serializer_with_fallback_test.rb

@@ -64,17 +64,18 @@ class MessagesSerializerWithFallbackTest < ActiveSupport::TestCase
     value = { "foo" => "bar" }
     dumped = serializer(:json).dump(value)
 
-    payloads = []
-    callback = -> (*args) { payloads << args.extract_options! }
-    ActiveSupport::Notifications.subscribed(callback, "message_serializer_fallback.active_support") do
-      serializer(:marshal).load(dumped)
+    expected_payload = {
+      serializer: :marshal,
+      fallback: :json,
+      serialized: dumped,
+      deserialized: value,
+    }
+
+    assert_notifications_count("message_serializer_fallback.active_support", 1) do
+      assert_notification("message_serializer_fallback.active_support", expected_payload) do
+        serializer(:marshal).load(dumped)
+      end
     end
-
-    assert_equal 1, payloads.length
-    assert_equal :marshal, payloads.first[:serializer]
-    assert_equal :json, payloads.first[:fallback]
-    assert_equal dumped, payloads.first[:serialized]
-    assert_equal value, payloads.first[:deserialized]
   end
 
   test "raises on invalid format name" do