From 6f7fc5824f2033c0f674b002dbee7f1c3f3384ac Mon Sep 17 00:00:00 2001
From: Jeremy Kemper <jeremy@bitsweat.net>
Date: Tue, 24 Nov 2009 19:26:13 -0800
Subject: Revert "Create SyncListener. Since they do not rely on Thread, they
 can be used on Google App Engine."

Take a step back on this API direction.

This reverts commit 8104f65c3225453d13307c3c2733c2a8f99e491a.
---
 activesupport/test/notifications_test.rb | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

(limited to 'activesupport/test')

diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 35d44367cf..01106e83e9 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -176,21 +176,6 @@ class NotificationsMainTest < Test::Unit::TestCase
     assert_equal 1, @another.first.result
   end
 
-  def test_subscriber_allows_sync_listeners
-    @another = []
-    ActiveSupport::Notifications.subscribe(/cache/, :with => ActiveSupport::Notifications::SyncListener) do |*args|
-      @another << ActiveSupport::Notifications::Event.new(*args)
-    end
-
-    Thread.expects(:new).never
-    ActiveSupport::Notifications.instrument(:something){ 0 }
-    ActiveSupport::Notifications.instrument(:cache){ 1 }
-
-    assert_equal 1, @another.size
-    assert_equal :cache, @another.first.name
-    assert_equal 1, @another.first.result
-  end
-
   def test_with_several_consumers_and_several_events
     @another = []
     ActiveSupport::Notifications.subscribe do |*args|
@@ -216,6 +201,6 @@ class NotificationsMainTest < Test::Unit::TestCase
 
   private
     def drain
-      sleep(0.05) until ActiveSupport::Notifications.queue.drained?
+      sleep(0.1) until ActiveSupport::Notifications.queue.drained?
     end
 end
-- 
cgit v1.2.3


From ddf681ce1d3e71aef913dd7f94c60b7622523f8b Mon Sep 17 00:00:00 2001
From: Jeremy Kemper <jeremy@bitsweat.net>
Date: Tue, 24 Nov 2009 19:35:01 -0800
Subject: Expose a simple Queue#wait to block until all notifications are
 drained

---
 activesupport/test/notifications_test.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activesupport/test')

diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 01106e83e9..3df2088ac9 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -201,6 +201,6 @@ class NotificationsMainTest < Test::Unit::TestCase
 
   private
     def drain
-      sleep(0.1) until ActiveSupport::Notifications.queue.drained?
+      ActiveSupport::Notifications.queue.wait
     end
 end
-- 
cgit v1.2.3


From 4f2a04cc085b9117e8af8079a95a063f671d7a3d Mon Sep 17 00:00:00 2001
From: Jeremy Kemper <jeremy@bitsweat.net>
Date: Sat, 28 Nov 2009 12:49:07 -0800
Subject: Notifications: extract central Notifier, cordon off the internal
 Fanout implementation, and segregate instrumentation concerns

---
 activesupport/test/notifications_test.rb | 270 +++++++++++++------------------
 1 file changed, 112 insertions(+), 158 deletions(-)

(limited to 'activesupport/test')

diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 3df2088ac9..93c61b2c83 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -1,206 +1,160 @@
 require 'abstract_unit'
 
-# Allow LittleFanout to be cleaned.
-class ActiveSupport::Notifications::LittleFanout
-  def clear
-    @listeners.clear
-  end
-end
+module Notifications
+  class TestCase < ActiveSupport::TestCase
+    def setup
+      Thread.abort_on_exception = true
+
+      @notifier = ActiveSupport::Notifications::Notifier.new
+      @events = []
+      @notifier.subscribe { |*args| @events << event(*args) }
+    end
 
-class NotificationsEventTest < Test::Unit::TestCase
-  def test_events_are_initialized_with_details
-    event = event(:foo, Time.now, Time.now + 1, 1, random_id, :payload => :bar)
-    assert_equal :foo, event.name
-    assert_equal Hash[:payload => :bar], event.payload
-  end
+    def teardown
+      Thread.abort_on_exception = false
+    end
 
-  def test_events_consumes_information_given_as_payload
-    time = Time.now
-    event = event(:foo, time, time + 0.01, 1, random_id, {})
+    private
+      def event(*args)
+        ActiveSupport::Notifications::Event.new(*args)
+      end
 
-    assert_equal Hash.new, event.payload
-    assert_equal time, event.time
-    assert_equal 1, event.result
-    assert_equal 10.0, event.duration
+      def drain
+        @notifier.wait
+      end
   end
 
-  def test_event_is_parent_based_on_time_frame
-    time = Time.utc(2009, 01, 01, 0, 0, 1)
+  class PubSubTest < TestCase
+    def test_events_are_published_to_a_listener
+      @notifier.publish :foo
+      @notifier.wait
+      assert_equal [[:foo]], @events
+    end
 
-    parent    = event(:foo, Time.utc(2009), Time.utc(2009) + 100, nil, random_id, {})
-    child     = event(:foo, time, time + 10, nil, random_id, {})
-    not_child = event(:foo, time, time + 100, nil, random_id, {})
+    def test_subscriber_with_pattern
+      events = []
+      @notifier.subscribe('1') { |*args| events << args }
 
-    assert parent.parent_of?(child)
-    assert !child.parent_of?(parent)
-    assert !parent.parent_of?(not_child)
-    assert !not_child.parent_of?(parent)
-  end
+      @notifier.publish '1'
+      @notifier.publish '1.a'
+      @notifier.publish 'a.1'
+      @notifier.wait
 
-protected
+      assert_equal [['1'], ['1.a']], events
+    end
 
-  def random_id
-    @random_id ||= ActiveSupport::SecureRandom.hex(10)
-  end
+    def test_subscriber_with_pattern_as_regexp
+      events = []
+      @notifier.subscribe(/\d/) { |*args| events << args }
 
-  def event(*args)
-    ActiveSupport::Notifications::Event.new(*args)
-  end
-end
+      @notifier.publish '1'
+      @notifier.publish 'a.1'
+      @notifier.publish '1.a'
+      @notifier.wait
 
-class NotificationsMainTest < Test::Unit::TestCase
-  def setup
-    @events = []
-    Thread.abort_on_exception = true
-    ActiveSupport::Notifications.subscribe do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
+      assert_equal [['1'], ['a.1'], ['1.a']], events
     end
-  end
 
-  def teardown
-    Thread.abort_on_exception = false
-    ActiveSupport::Notifications.queue.clear
-  end
+    def test_multiple_subscribers
+      @another = []
+      @notifier.subscribe { |*args| @another << args }
+      @notifier.publish :foo
+      @notifier.wait
 
-  def test_notifications_returns_action_result
-    result = ActiveSupport::Notifications.instrument(:awesome, :payload => "notifications") do
-      1 + 1
+      assert_equal [[:foo]], @events
+      assert_equal [[:foo]], @another
     end
 
-    assert_equal 2, result
+    private
+      def event(*args)
+        args
+      end
   end
 
-  def test_events_are_published_to_a_listener
-    ActiveSupport::Notifications.instrument(:awesome, :payload => "notifications") do
-      1 + 1
+  class InstrumentationTest < TestCase
+    def test_instrument_returns_block_result
+      assert_equal 2, @notifier.instrument(:awesome) { 1 + 1 }
     end
 
-    drain
+    def test_nested_events_can_be_instrumented
+      @notifier.instrument(:awesome, :payload => "notifications") do
+        @notifier.instrument(:wot, :payload => "child") do
+          1 + 1
+        end
 
-    assert_equal 1, @events.size
-    assert_equal :awesome, @events.last.name
-    assert_equal Hash[:payload => "notifications"], @events.last.payload
-  end
+        drain
 
-  def test_nested_events_can_be_instrumented
-    ActiveSupport::Notifications.instrument(:awesome, :payload => "notifications") do
-      ActiveSupport::Notifications.instrument(:wot, :payload => "child") do
-        1 + 1
+        assert_equal 1, @events.size
+        assert_equal :wot, @events.first.name
+        assert_equal Hash[:payload => "child"], @events.first.payload
       end
 
       drain
 
-      assert_equal 1, @events.size
-      assert_equal :wot, @events.first.name
-      assert_equal Hash[:payload => "child"], @events.first.payload
+      assert_equal 2, @events.size
+      assert_equal :awesome, @events.last.name
+      assert_equal Hash[:payload => "notifications"], @events.last.payload
     end
 
-    drain
-
-    assert_equal 2, @events.size
-    assert_equal :awesome, @events.last.name
-    assert_equal Hash[:payload => "notifications"], @events.last.payload
-  end
-
-  def test_event_is_pushed_even_if_block_fails
-    ActiveSupport::Notifications.instrument(:awesome, :payload => "notifications") do
-      raise "OMG"
-    end rescue RuntimeError
-
-    drain
-
-    assert_equal 1, @events.size
-    assert_equal :awesome, @events.last.name
-    assert_equal Hash[:payload => "notifications"], @events.last.payload
-  end
-
-  def test_event_is_pushed_even_without_block
-    ActiveSupport::Notifications.instrument(:awesome, :payload => "notifications")
-    drain
-
-    assert_equal 1, @events.size
-    assert_equal :awesome, @events.last.name
-    assert_equal Hash[:payload => "notifications"], @events.last.payload
-  end
-
-  def test_subscribed_in_a_transaction
-    @another = []
+    def test_instrument_publishes_when_exception_is_raised
+      begin
+        @notifier.instrument(:awesome, :payload => "notifications") do
+          raise "OMG"
+        end
+        flunk
+      rescue
+      end
 
-    ActiveSupport::Notifications.subscribe("cache") do |*args|
-      @another << ActiveSupport::Notifications::Event.new(*args)
-    end
+      drain
 
-    ActiveSupport::Notifications.instrument(:cache){ 1 }
-    ActiveSupport::Notifications.transaction do
-      ActiveSupport::Notifications.instrument(:cache){ 1 }
+      assert_equal 1, @events.size
+      assert_equal :awesome, @events.last.name
+      assert_equal Hash[:payload => "notifications"], @events.last.payload
     end
-    ActiveSupport::Notifications.instrument(:cache){ 1 }
-
-    drain
 
-    assert_equal 3, @another.size
-    before, during, after = @another.map {|e| e.transaction_id }
-    assert_equal before, after
-    assert_not_equal before, during
-  end
-
-  def test_subscriber_with_pattern
-    @another = []
+    def test_event_is_pushed_even_without_block
+      @notifier.instrument(:awesome, :payload => "notifications")
+      drain
 
-    ActiveSupport::Notifications.subscribe("cache") do |*args|
-      @another << ActiveSupport::Notifications::Event.new(*args)
+      assert_equal 1, @events.size
+      assert_equal :awesome, @events.last.name
+      assert_equal Hash[:payload => "notifications"], @events.last.payload
     end
-
-    ActiveSupport::Notifications.instrument(:cache){ 1 }
-
-    drain
-
-    assert_equal 1, @another.size
-    assert_equal :cache, @another.first.name
-    assert_equal 1, @another.first.result
   end
 
-  def test_subscriber_with_pattern_as_regexp
-    @another = []
-    ActiveSupport::Notifications.subscribe(/cache/) do |*args|
-      @another << ActiveSupport::Notifications::Event.new(*args)
+  class EventTest < TestCase
+    def test_events_are_initialized_with_details
+      event = event(:foo, Time.now, Time.now + 1, 1, random_id, :payload => :bar)
+      assert_equal :foo, event.name
+      assert_equal Hash[:payload => :bar], event.payload
     end
 
-    ActiveSupport::Notifications.instrument(:something){ 0 }
-    ActiveSupport::Notifications.instrument(:cache){ 1 }
-
-    drain
-
-    assert_equal 1, @another.size
-    assert_equal :cache, @another.first.name
-    assert_equal 1, @another.first.result
-  end
+    def test_events_consumes_information_given_as_payload
+      time = Time.now
+      event = event(:foo, time, time + 0.01, 1, random_id, {})
 
-  def test_with_several_consumers_and_several_events
-    @another = []
-    ActiveSupport::Notifications.subscribe do |*args|
-      @another << ActiveSupport::Notifications::Event.new(*args)
+      assert_equal Hash.new, event.payload
+      assert_equal time, event.time
+      assert_equal 1, event.result
+      assert_equal 10.0, event.duration
     end
 
-    1.upto(100) do |i|
-      ActiveSupport::Notifications.instrument(:value){ i }
-    end
+    def test_event_is_parent_based_on_time_frame
+      time = Time.utc(2009, 01, 01, 0, 0, 1)
 
-    drain
+      parent    = event(:foo, Time.utc(2009), Time.utc(2009) + 100, nil, random_id, {})
+      child     = event(:foo, time, time + 10, nil, random_id, {})
+      not_child = event(:foo, time, time + 100, nil, random_id, {})
 
-    assert_equal 100, @events.size
-    assert_equal :value, @events.first.name
-    assert_equal 1, @events.first.result
-    assert_equal 100, @events.last.result
+      assert parent.parent_of?(child)
+      assert !child.parent_of?(parent)
+      assert !parent.parent_of?(not_child)
+      assert !not_child.parent_of?(parent)
+    end
 
-    assert_equal 100, @another.size
-    assert_equal :value, @another.first.name
-    assert_equal 1, @another.first.result
-    assert_equal 100, @another.last.result
+    protected
+      def random_id
+        @random_id ||= ActiveSupport::SecureRandom.hex(10)
+      end
   end
-
-  private
-    def drain
-      ActiveSupport::Notifications.queue.wait
-    end
 end
-- 
cgit v1.2.3


From 327545c3ae904d1a9c67de3e280c182ed6418023 Mon Sep 17 00:00:00 2001
From: Jeremy Kemper <jeremy@bitsweat.net>
Date: Sun, 29 Nov 2009 02:30:35 -0800
Subject: Notifications: synchronous fanout queue pushes events to subscribers
 rather than having them concurrently pull

---
 activesupport/test/notifications_test.rb | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'activesupport/test')

diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 93c61b2c83..4f880d0db7 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -71,6 +71,16 @@ module Notifications
       end
   end
 
+  class SyncPubSubTest < PubSubTest
+    def setup
+      Thread.abort_on_exception = true
+
+      @notifier = ActiveSupport::Notifications::Notifier.new(ActiveSupport::Notifications::Fanout.new(true))
+      @events = []
+      @notifier.subscribe { |*args| @events << event(*args) }
+    end
+  end
+
   class InstrumentationTest < TestCase
     def test_instrument_returns_block_result
       assert_equal 2, @notifier.instrument(:awesome) { 1 + 1 }
-- 
cgit v1.2.3