Move `channel_name` to Channel.broadcasting_for

That would allow us to test broadcasting made with channel, e.g.:

```ruby
class ChatRelayJob < ApplicationJob
  def perform_later(room, msg)
    ChatChannel.broadcast_to room, message: msg
  end
end
```

To test this functionality we need to know the underlying stream name
(to use `assert_broadcasts`), which relies on `channel_name`.

We had to use the following code:

```ruby
assert_broadcasts(ChatChannel.broadcasting_for([ChatChannel.channel_name, room]), 1) do
  ChatRelayJob.perform_now
end
```

The problem with this approach is that we use _internal_ API (we shouldn't care about `channel_name` prefix
in our code).

With this commit we could re-write the test as following:

```ruby
 assert_broadcasts(ChatChannel.broadcasting_for(room), 1) do
   ChatRelayJob.perform_now
 end
```

5 files changed, 53 insertions, 14 deletions

diff --git a/actioncable/lib/action_cable/channel/broadcasting.rb b/actioncable/lib/action_cable/channel/broadcasting.rb
index 9a96720f4a..bd900e1c65 100644
--- a/actioncable/lib/action_cable/channel/broadcasting.rb
+++ b/actioncable/lib/action_cable/channel/broadcasting.rb
@@ -12,17 +12,22 @@ module ActionCable
       module ClassMethods
         # Broadcast a hash to a unique broadcasting for this <tt>model</tt> in this channel.
         def broadcast_to(model, message)
-          ActionCable.server.broadcast(broadcasting_for([ channel_name, model ]), message)
+          ActionCable.server.broadcast(broadcasting_for(model), message)
         end
 
-        def broadcasting_for(model) #:nodoc:
+        # Returns a unique broadcasting identifier for this <tt>model</tt> in this channel.
+        def broadcasting_for(model)
+          serialize_broadcasting([ channel_name, model ])
+        end
+
+        def serialize_broadcasting(object) #:nodoc:
           case
-          when model.is_a?(Array)
-            model.map { |m| broadcasting_for(m) }.join(":")
-          when model.respond_to?(:to_gid_param)
-            model.to_gid_param
+          when object.is_a?(Array)
+            object.map { |m| serialize_broadcasting(m) }.join(":")
+          when object.respond_to?(:to_gid_param)
+            object.to_gid_param
           else
-            model.to_param
+            object.to_param
           end
         end
       end
diff --git a/actioncable/lib/action_cable/channel/streams.rb b/actioncable/lib/action_cable/channel/streams.rb
index 81c2c38064..7e1ed3c850 100644
--- a/actioncable/lib/action_cable/channel/streams.rb
+++ b/actioncable/lib/action_cable/channel/streams.rb
@@ -99,7 +99,7 @@ module ActionCable
       # Pass <tt>coder: ActiveSupport::JSON</tt> to decode messages as JSON before passing to the callback.
       # Defaults to <tt>coder: nil</tt> which does no decoding, passes raw messages.
       def stream_for(model, callback = nil, coder: nil, &block)
-        stream_from(broadcasting_for([ channel_name, model ]), callback || block, coder: coder)
+        stream_from(broadcasting_for(model), callback || block, coder: coder)
       end
 
       # Unsubscribes all streams associated with this channel from the pubsub queue.
diff --git a/actioncable/lib/action_cable/channel/test_case.rb b/actioncable/lib/action_cable/channel/test_case.rb
index c4cf0ac0e7..19d6f1cccf 100644
--- a/actioncable/lib/action_cable/channel/test_case.rb
+++ b/actioncable/lib/action_cable/channel/test_case.rb
@@ -300,9 +300,7 @@ module ActionCable
           def broadcasting_for(stream_or_object)
             return stream_or_object if stream_or_object.is_a?(String)
 
-            self.class.channel_class.broadcasting_for(
-              [self.class.channel_class.channel_name, stream_or_object]
-            )
+            self.class.channel_class.broadcasting_for(stream_or_object)
           end
       end
 
diff --git a/actioncable/test/channel/broadcasting_test.rb b/actioncable/test/channel/broadcasting_test.rb
index 2cbfabc1d0..fb501a1bc2 100644
--- a/actioncable/test/channel/broadcasting_test.rb
+++ b/actioncable/test/channel/broadcasting_test.rb
@@ -26,14 +26,23 @@ class ActionCable::Channel::BroadcastingTest < ActionCable::TestCase
   end
 
   test "broadcasting_for with an object" do
-    assert_equal "Room#1-Campfire", ChatChannel.broadcasting_for(Room.new(1))
+    assert_equal(
+      "action_cable:channel:broadcasting_test:chat:Room#1-Campfire",
+      ChatChannel.broadcasting_for(Room.new(1))
+    )
   end
 
   test "broadcasting_for with an array" do
-    assert_equal "Room#1-Campfire:Room#2-Campfire", ChatChannel.broadcasting_for([ Room.new(1), Room.new(2) ])
+    assert_equal(
+      "action_cable:channel:broadcasting_test:chat:Room#1-Campfire:Room#2-Campfire",
+      ChatChannel.broadcasting_for([ Room.new(1), Room.new(2) ])
+    )
   end
 
   test "broadcasting_for with a string" do
-    assert_equal "hello", ChatChannel.broadcasting_for("hello")
+    assert_equal(
+      "action_cable:channel:broadcasting_test:chat:hello",
+      ChatChannel.broadcasting_for("hello")
+    )
   end
 end
diff --git a/guides/source/testing.md b/guides/source/testing.md
index 1a2f480407..fb78fa6d17 100644
--- a/guides/source/testing.md
+++ b/guides/source/testing.md
@@ -1837,6 +1837,33 @@ class ProductTest < ActionCable::TestCase
 end
 ```
 
+If you want to test the broadcasting made with `Channel.broadcast_to`, you shoud use
+`Channel.broadcasting_for` to generate an underlying stream name:
+
+```ruby
+# app/jobs/chat_relay_job.rb
+class ChatRelayJob < ApplicationJob
+  def perform_later(room, message)
+    ChatChannel.broadcast_to room, text: message
+  end
+end
+
+# test/jobs/chat_relay_job_test.rb
+require 'test_helper'
+
+class ChatRelayJobTest < ActiveJob::TestCase
+  include ActionCable::TestHelper
+
+  test "broadcast message to room" do
+    room = rooms[:all]
+
+    assert_broadcast_on(ChatChannel.broadcasting_for(room), text: "Hi!") do
+      ChatRelayJob.perform_now(room, "Hi!")
+    end
+  end
+end
+```
+
 Additional Testing Resources
 ----------------------------