Add advance_time helper to drive periodic timers in tests

Lets tests assert on `periodically` callback behavior without a real clock.

Author: joeljunstrom

lib/action_cable/channel/test_case.rb

@@ -238,6 +238,15 @@ def perform(action, data = {})
           subscription.perform_action(data.stringify_keys.merge("action" => action.to_s))
         end
 
+        # Advance the virtual clock used by `periodically` timers.
+        #
+        #     subscribe
+        #     advance_time 5.seconds
+        #     assert_equal 1, subscription.tick_count
+        def advance_time(seconds)
+          testserver.advance_time(seconds)
+        end
+
         # Returns messages transmitted into channel
         def transmissions
           # Return only directly sent message (via #transmit)

lib/action_cable/connection/test_case.rb

@@ -100,19 +100,44 @@ def transmit(data)
       def close
         @closed = true
       end
+
+      def perform_work(receiver, method_name, *args)
+        receiver.public_send(method_name, *args)
+      end
     end
 
     class TestTimer
-      def shutdown; end
+      attr_reader :interval
+
+      def initialize(interval, &block)
+        @interval = interval
+        @block = block
+        @elapsed = 0
+        @shutdown = false
+      end
+
+      def shutdown
+        @shutdown = true
+      end
+
+      def advance(seconds)
+        return if @shutdown
+        @elapsed += seconds
+        while @elapsed >= @interval
+          @elapsed -= @interval
+          @block&.call
+        end
+      end
     end
 
     # TestServer provides test pub/sub and executor implementations
     class TestServer
-      attr_reader :streams, :config
+      attr_reader :streams, :config, :timers
 
       def initialize(server)
         @streams = Hash.new { |h, k| h[k] = [] }
         @config = server.config
+        @timers = []
       end
 
       alias_method :pubsub, :itself
@@ -122,7 +147,14 @@ def initialize(server)
 
       # Inline async calls
       def post(&work) = work.call
-      def timer(_every) = TestTimer.new
+
+      def timer(every, &block)
+        TestTimer.new(every, &block).tap { |t| @timers << t }
+      end
+
+      def advance_time(seconds)
+        @timers.each { |timer| timer.advance(seconds) }
+      end
 
       #== Pub/sub interface ==
       def subscribe(stream, callback, success_callback = nil)

test/channel/test_case_test.rb

@@ -115,6 +115,49 @@ def test_reject_does_not_crash_when_periodic_timer_is_registered
   end
 end
 
+class PeriodicCounterChannel < ActionCable::Channel::Base
+  periodically :tick, every: 5
+
+  attr_reader :tick_count
+
+  def subscribed
+    @tick_count = 0
+  end
+
+  private
+    def tick
+      @tick_count += 1
+    end
+end
+
+class PeriodicCounterChannelTest < ActionCable::Channel::TestCase
+  tests PeriodicCounterChannel
+
+  def test_advance_time_fires_periodic_callback_when_interval_is_reached
+    subscribe
+    assert_equal 0, subscription.tick_count
+
+    advance_time 4
+    assert_equal 0, subscription.tick_count
+
+    advance_time 1
+    assert_equal 1, subscription.tick_count
+
+    advance_time 12
+    assert_equal 3, subscription.tick_count
+  end
+
+  def test_shutdown_timer_stops_firing_after_unsubscribe
+    subscribe
+    advance_time 5
+    assert_equal 1, subscription.tick_count
+
+    unsubscribe
+    advance_time 100
+    assert_equal 1, subscription.tick_count
+  end
+end
+
 class StreamsTestChannel < ActionCable::Channel::Base
   def subscribed
     stream_from "test_#{params[:id] || 0}"