15 files changed, 388 insertions, 9 deletions
diff --git a/actioncable/CHANGELOG.md b/actioncable/CHANGELOG.md
index 959943016f..17c7e9a3b7 100644
--- a/actioncable/CHANGELOG.md
+++ b/actioncable/CHANGELOG.md
@@ -1,3 +1,21 @@
+*   Add `id` option to redis adapter so now you can distinguish
+    ActionCable's redis connections among others. Also, you can set
+    custom id in options.
+
+    Before:
+    ```
+    $ redis-cli client list
+    id=669 addr=127.0.0.1:46442 fd=8 name= age=18 ...
+    ```
+
+    After:
+    ```
+    $ redis-cli client list
+    id=673 addr=127.0.0.1:46516 fd=8 name=ActionCable-PID-19413 age=2 ...
+    ```
+
+    *Ilia Kasianenko*
+
 *   Rails 6 requires Ruby 2.4.1 or newer.
 
     *Jeremy Daer*
diff --git a/actioncable/README.md b/actioncable/README.md
index a05ef1dd20..d6893dbab1 100644
--- a/actioncable/README.md
+++ b/actioncable/README.md
@@ -425,7 +425,7 @@ The above will start a cable server on port 28080.
 
 ### In app
 
-If you are using a server that supports the [Rack socket hijacking API](http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking), Action Cable can run alongside your Rails application. For example, to listen for WebSocket requests on `/websocket`, specify that path to `config.action_cable.mount_path`:
+If you are using a server that supports the [Rack socket hijacking API](https://www.rubydoc.info/github/rack/rack/file/SPEC#label-Hijacking), Action Cable can run alongside your Rails application. For example, to listen for WebSocket requests on `/websocket`, specify that path to `config.action_cable.mount_path`:
 
 ```ruby
 # config/application.rb
@@ -459,7 +459,7 @@ support, which means you can use all your regular Rails models with no problems
 as long as you haven't committed any thread-safety sins.
 
 The Action Cable server does _not_ need to be a multi-threaded application server.
-This is because Action Cable uses the [Rack socket hijacking API](http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking)
+This is because Action Cable uses the [Rack socket hijacking API](https://www.rubydoc.info/github/rack/rack/file/SPEC#label-Hijacking)
 to take over control of connections from the application server. Action Cable
 then manages connections internally, in a multithreaded manner, regardless of
 whether the application server is multi-threaded or not. So Action Cable works
diff --git a/actioncable/Rakefile b/actioncable/Rakefile
index 226d171104..fb75d14363 100644
--- a/actioncable/Rakefile
+++ b/actioncable/Rakefile
@@ -57,7 +57,7 @@ namespace :assets do
     end
 
     print "[verify] #{file} is a UMD module "
-    if pathname.read =~ /module\.exports.*define\.amd/m
+    if /module\.exports.*define\.amd/m.match?(pathname.read)
       puts "[OK]"
     else
       $stderr.puts "[FAIL]"
diff --git a/actioncable/lib/action_cable.rb b/actioncable/lib/action_cable.rb
index e7456e3c1b..35eacc2f4f 100644
--- a/actioncable/lib/action_cable.rb
+++ b/actioncable/lib/action_cable.rb
@@ -51,4 +51,6 @@ module ActionCable
   autoload :Channel
   autoload :RemoteConnections
   autoload :SubscriptionAdapter
+  autoload :TestHelper
+  autoload :TestCase
 end
diff --git a/actioncable/lib/action_cable/subscription_adapter.rb b/actioncable/lib/action_cable/subscription_adapter.rb
index bcece8d33b..6a9d5c2080 100644
--- a/actioncable/lib/action_cable/subscription_adapter.rb
+++ b/actioncable/lib/action_cable/subscription_adapter.rb
@@ -5,6 +5,7 @@ module ActionCable
     extend ActiveSupport::Autoload
 
     autoload :Base
+    autoload :Test
     autoload :SubscriberMap
     autoload :ChannelPrefix
   end
diff --git a/actioncable/lib/action_cable/subscription_adapter/redis.rb b/actioncable/lib/action_cable/subscription_adapter/redis.rb
index c28951608f..ad8fa52760 100644
--- a/actioncable/lib/action_cable/subscription_adapter/redis.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/redis.rb
@@ -13,7 +13,8 @@ module ActionCable
       # Overwrite this factory method for Redis connections if you want to use a different Redis library than the redis gem.
       # This is needed, for example, when using Makara proxies for distributed Redis.
       cattr_accessor :redis_connector, default: ->(config) do
-        ::Redis.new(config.slice(:url, :host, :port, :db, :password))
+        config[:id] ||= "ActionCable-PID-#{$$}"
+        ::Redis.new(config.slice(:url, :host, :port, :db, :password, :id))
       end
 
       def initialize(*)
diff --git a/actioncable/lib/action_cable/subscription_adapter/test.rb b/actioncable/lib/action_cable/subscription_adapter/test.rb
new file mode 100644
index 0000000000..ce604cc88e
--- /dev/null
+++ b/actioncable/lib/action_cable/subscription_adapter/test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "async"
+
+module ActionCable
+  module SubscriptionAdapter
+    # == Test adapter for Action Cable
+    #
+    # The test adapter should be used only in testing. Along with
+    # <tt>ActionCable::TestHelper</tt> it makes a great tool to test your Rails application.
+    #
+    # To use the test adapter set +adapter+ value to +test+ in your +config/cable.yml+ file.
+    #
+    # NOTE: Test adapter extends the <tt>ActionCable::SubscriptionsAdapter::Async</tt> adapter,
+    # so it could be used in system tests too.
+    class Test < Async
+      def broadcast(channel, payload)
+        broadcasts(channel) << payload
+        super
+      end
+
+      def broadcasts(channel)
+        channels_data[channel] ||= []
+      end
+
+      def clear_messages(channel)
+        channels_data[channel] = []
+      end
+
+      def clear
+        @channels_data = nil
+      end
+
+      private
+        def channels_data
+          @channels_data ||= {}
+        end
+    end
+  end
+end
diff --git a/actioncable/lib/action_cable/test_case.rb b/actioncable/lib/action_cable/test_case.rb
new file mode 100644
index 0000000000..d153259bf6
--- /dev/null
+++ b/actioncable/lib/action_cable/test_case.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/test_case"
+
+module ActionCable
+  class TestCase < ActiveSupport::TestCase
+    include ActionCable::TestHelper
+
+    ActiveSupport.run_load_hooks(:action_cable_test_case, self)
+  end
+end
diff --git a/actioncable/lib/action_cable/test_helper.rb b/actioncable/lib/action_cable/test_helper.rb
new file mode 100644
index 0000000000..7bc877663c
--- /dev/null
+++ b/actioncable/lib/action_cable/test_helper.rb
@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ActionCable
+  # Provides helper methods for testing Action Cable broadcasting
+  module TestHelper
+    def before_setup # :nodoc:
+      server = ActionCable.server
+      test_adapter = ActionCable::SubscriptionAdapter::Test.new(server)
+
+      @old_pubsub_adapter = server.pubsub
+
+      server.instance_variable_set(:@pubsub, test_adapter)
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      ActionCable.server.instance_variable_set(:@pubsub, @old_pubsub_adapter)
+    end
+
+    # Asserts that the number of broadcasted messages to the stream matches the given number.
+    #
+    #   def test_broadcasts
+    #     assert_broadcasts 'messages', 0
+    #     ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #     assert_broadcasts 'messages', 1
+    #     ActionCable.server.broadcast 'messages', { text: 'world' }
+    #     assert_broadcasts 'messages', 2
+    #   end
+    #
+    # If a block is passed, that block should cause the specified number of
+    # messages to be broadcasted.
+    #
+    #   def test_broadcasts_again
+    #     assert_broadcasts('messages', 1) do
+    #       ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #     end
+    #
+    #     assert_broadcasts('messages', 2) do
+    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #       ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #     end
+    #   end
+    #
+    def assert_broadcasts(stream, number)
+      if block_given?
+        original_count = broadcasts_size(stream)
+        yield
+        new_count = broadcasts_size(stream)
+        actual_count = new_count - original_count
+      else
+        actual_count = broadcasts_size(stream)
+      end
+
+      assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+    end
+
+    # Asserts that no messages have been sent to the stream.
+    #
+    #   def test_no_broadcasts
+    #     assert_no_broadcasts 'messages'
+    #     ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #     assert_broadcasts 'messages', 1
+    #   end
+    #
+    # If a block is passed, that block should not cause any message to be sent.
+    #
+    #   def test_broadcasts_again
+    #     assert_no_broadcasts 'messages' do
+    #       # No job messages should be sent from this block
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_broadcasts 'messages', 0, &block
+    #
+    def assert_no_broadcasts(stream, &block)
+      assert_broadcasts stream, 0, &block
+    end
+
+    # Asserts that the specified message has been sent to the stream.
+    #
+    #   def test_assert_transmited_message
+    #     ActionCable.server.broadcast 'messages', text: 'hello'
+    #     assert_broadcast_on('messages', text: 'hello')
+    #   end
+    #
+    # If a block is passed, that block should cause a message with the specified data to be sent.
+    #
+    #   def test_assert_broadcast_on_again
+    #     assert_broadcast_on('messages', text: 'hello') do
+    #       ActionCable.server.broadcast 'messages', text: 'hello'
+    #     end
+    #   end
+    #
+    def assert_broadcast_on(stream, data)
+      # Encode to JSON and back–we want to use this value to compare
+      # with decoded JSON.
+      # Comparing JSON strings doesn't work due to the order if the keys.
+      serialized_msg =
+        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
+
+      new_messages = broadcasts(stream)
+      if block_given?
+        old_messages = new_messages
+        clear_messages(stream)
+
+        yield
+        new_messages = broadcasts(stream)
+        clear_messages(stream)
+
+        # Restore all sent messages
+        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+      end
+
+      message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
+
+      assert message, "No messages sent with #{data} to #{stream}"
+    end
+
+    def pubsub_adapter # :nodoc:
+      ActionCable.server.pubsub
+    end
+
+    delegate :broadcasts, :clear_messages, to: :pubsub_adapter
+
+    private
+      def broadcasts_size(channel)
+        broadcasts(channel).size
+      end
+  end
+end
diff --git a/actioncable/test/connection/client_socket_test.rb b/actioncable/test/connection/client_socket_test.rb
index 9176c7ac8b..a7db32c3e4 100644
--- a/actioncable/test/connection/client_socket_test.rb
+++ b/actioncable/test/connection/client_socket_test.rb
@@ -41,7 +41,6 @@ class ActionCable::Connection::ClientSocketTest < ActionCable::TestCase
       # Internal hax = :(
       client = connection.websocket.send(:websocket)
       client.instance_variable_get("@stream").stub(:write, proc { raise "foo" }) do
-
         assert_not_called(client, :client_gone) do
           client.write("boo")
         end
diff --git a/actioncable/test/javascript/vendor/mock-socket.js b/actioncable/test/javascript/vendor/mock-socket.js
index b465c8b53f..4564cebc40 100644
--- a/actioncable/test/javascript/vendor/mock-socket.js
+++ b/actioncable/test/javascript/vendor/mock-socket.js
@@ -178,7 +178,7 @@
     if (root.IPv6 === this) {
       root.IPv6 = _IPv6;
     }
-  
+
     return this;
   }
 
@@ -461,7 +461,6 @@
 }(this, function (punycode, IPv6, SLD, root) {
   'use strict';
   /*global location, escape, unescape */
-  // FIXME: v2.0.0 renamce non-camelCase properties to uppercase
   /*jshint camelcase: false */
 
   // save current URI variable, if any
diff --git a/actioncable/test/subscription_adapter/redis_test.rb b/actioncable/test/subscription_adapter/redis_test.rb
index 3dc995331a..ac2d8ef724 100644
--- a/actioncable/test/subscription_adapter/redis_test.rb
+++ b/actioncable/test/subscription_adapter/redis_test.rb
@@ -30,14 +30,22 @@ class RedisAdapterTest::AlternateConfiguration < RedisAdapterTest
 end
 
 class RedisAdapterTest::Connector < ActionCable::TestCase
-  test "slices url, host, port, db, and password from config" do
-    config = { url: 1, host: 2, port: 3, db: 4, password: 5 }
+  test "slices url, host, port, db, password and id from config" do
+    config = { url: 1, host: 2, port: 3, db: 4, password: 5, id: "Some custom ID" }
 
     assert_called_with ::Redis, :new, [ config ] do
       connect config.merge(other: "unrelated", stuff: "here")
     end
   end
 
+  test "adds default id if it is not specified" do
+    config = { url: 1, host: 2, port: 3, db: 4, password: 5, id: "ActionCable-PID-#{$$}" }
+
+    assert_called_with ::Redis, :new, [ config ] do
+      connect config.except(:id)
+    end
+  end
+
   def connect(config)
     ActionCable::SubscriptionAdapter::Redis.redis_connector.call(config)
   end
diff --git a/actioncable/test/subscription_adapter/test_adapter_test.rb b/actioncable/test/subscription_adapter/test_adapter_test.rb
new file mode 100644
index 0000000000..3fe07adb4a
--- /dev/null
+++ b/actioncable/test/subscription_adapter/test_adapter_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "common"
+
+class ActionCable::SubscriptionAdapter::TestTest < ActionCable::TestCase
+  include CommonSubscriptionAdapterTest
+
+  def setup
+    super
+
+    @tx_adapter.shutdown
+    @tx_adapter = @rx_adapter
+  end
+
+  def cable_config
+    { adapter: "test" }
+  end
+
+  test "#broadcast stores messages for streams" do
+    @tx_adapter.broadcast("channel", "payload")
+    @tx_adapter.broadcast("channel2", "payload2")
+
+    assert_equal ["payload"], @tx_adapter.broadcasts("channel")
+    assert_equal ["payload2"], @tx_adapter.broadcasts("channel2")
+  end
+
+  test "#clear_messages deletes recorded broadcasts for the channel" do
+    @tx_adapter.broadcast("channel", "payload")
+    @tx_adapter.broadcast("channel2", "payload2")
+
+    @tx_adapter.clear_messages("channel")
+
+    assert_equal [], @tx_adapter.broadcasts("channel")
+    assert_equal ["payload2"], @tx_adapter.broadcasts("channel2")
+  end
+
+  test "#clear deletes all recorded broadcasts" do
+    @tx_adapter.broadcast("channel", "payload")
+    @tx_adapter.broadcast("channel2", "payload2")
+
+    @tx_adapter.clear
+
+    assert_equal [], @tx_adapter.broadcasts("channel")
+    assert_equal [], @tx_adapter.broadcasts("channel2")
+  end
+end
diff --git a/actioncable/test/test_helper.rb b/actioncable/test/test_helper.rb
index ac7881c950..c924f1e475 100644
--- a/actioncable/test/test_helper.rb
+++ b/actioncable/test/test_helper.rb
@@ -15,6 +15,10 @@ end
 # Require all the stubs and models
 Dir[File.expand_path("stubs/*.rb", __dir__)].each { |file| require file }
 
+# Set test adapter and logger
+ActionCable.server.config.cable = { "adapter" => "test" }
+ActionCable.server.config.logger = Logger.new(nil)
+
 class ActionCable::TestCase < ActiveSupport::TestCase
   include ActiveSupport::Testing::MethodCallAssertions
 
diff --git a/actioncable/test/test_helper_test.rb b/actioncable/test/test_helper_test.rb
new file mode 100644
index 0000000000..90e3dbf01f
--- /dev/null
+++ b/actioncable/test/test_helper_test.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class BroadcastChannel < ActionCable::Channel::Base
+end
+
+class TransmissionsTest < ActionCable::TestCase
+  def test_assert_broadcasts
+    assert_nothing_raised do
+      assert_broadcasts("test", 1) do
+        ActionCable.server.broadcast "test", "message"
+      end
+    end
+  end
+
+  def test_assert_broadcasts_with_no_block
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "message"
+      assert_broadcasts "test", 1
+    end
+
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "message 2"
+      ActionCable.server.broadcast "test", "message 3"
+      assert_broadcasts "test", 3
+    end
+  end
+
+  def test_assert_no_broadcasts_with_no_block
+    assert_nothing_raised do
+      assert_no_broadcasts "test"
+    end
+  end
+
+  def test_assert_no_broadcasts
+    assert_nothing_raised do
+      assert_no_broadcasts("test") do
+        ActionCable.server.broadcast "test2", "message"
+      end
+    end
+  end
+
+  def test_assert_broadcasts_message_too_few_sent
+    ActionCable.server.broadcast "test", "hello"
+    error = assert_raises Minitest::Assertion do
+      assert_broadcasts("test", 2) do
+        ActionCable.server.broadcast "test", "world"
+      end
+    end
+
+    assert_match(/2 .* but 1/, error.message)
+  end
+
+  def test_assert_broadcasts_message_too_many_sent
+    error = assert_raises Minitest::Assertion do
+      assert_broadcasts("test", 1) do
+        ActionCable.server.broadcast "test", "hello"
+        ActionCable.server.broadcast "test", "world"
+      end
+    end
+
+    assert_match(/1 .* but 2/, error.message)
+  end
+
+  def test_assert_no_broadcasts_failure
+    error = assert_raises Minitest::Assertion do
+      assert_no_broadcasts "test" do
+        ActionCable.server.broadcast "test", "hello"
+      end
+    end
+
+    assert_match(/0 .* but 1/, error.message)
+  end
+end
+
+class TransmitedDataTest < ActionCable::TestCase
+  include ActionCable::TestHelper
+
+  def test_assert_broadcast_on
+    assert_nothing_raised do
+      assert_broadcast_on("test", "message") do
+        ActionCable.server.broadcast "test", "message"
+      end
+    end
+  end
+
+  def test_assert_broadcast_on_with_hash
+    assert_nothing_raised do
+      assert_broadcast_on("test", text: "hello") do
+        ActionCable.server.broadcast "test", text: "hello"
+      end
+    end
+  end
+
+  def test_assert_broadcast_on_with_no_block
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "hello"
+      assert_broadcast_on "test", "hello"
+    end
+
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "world"
+      assert_broadcast_on "test", "world"
+    end
+  end
+
+  def test_assert_broadcast_on_message
+    ActionCable.server.broadcast "test", "hello"
+    error = assert_raises Minitest::Assertion do
+      assert_broadcast_on("test", "world")
+    end
+
+    assert_match(/No messages sent/, error.message)
+  end
+end