Action Cable for real-time updates in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a client subscribes to a channel in Action Cable?

Consider a Rails app using Action Cable. When a client subscribes to a channel, what is the immediate effect on the server side?

A The server sends a static HTML page to the client as a response.

B The server starts streaming data to the client immediately without any further action.

C The server closes the connection until the client sends a confirmation message.

D The server creates a subscription instance and waits for client messages or broadcasts to send data.

💡 Hint

Think about how Action Cable manages connections and data flow after subscription.

When a client subscribes, the server creates a subscription instance. It does not send data immediately but waits for broadcasts or client messages to push updates.

📝 Syntax

intermediate

Identify the correct syntax to broadcast a message to a channel in Action Cable

Which of the following lines correctly broadcasts a JSON message {status: 'ok'} to a channel named 'NotificationsChannel'?

A ActionCable.server.send('NotificationsChannel', {status: 'ok'})

B ActionCable.broadcast('NotificationsChannel', {status: 'ok'})

C ActionCable.server.broadcast('NotificationsChannel', {status: 'ok'})

D ActionCable.broadcast_to('NotificationsChannel', {status: 'ok'})

💡 Hint

Remember the method to send data from server to all subscribers of a channel.

The correct method is ActionCable.server.broadcast which sends data to all subscribers of the given channel.

🔧 Debug

advanced

Why does this Action Cable subscription not receive broadcasts?

Given this subscription code in app/channels/chat_channel.rb:

class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from 'chat_channel'
  end
end

And this broadcast call in a controller:

ActionCable.server.broadcast('chat_channel', message: 'Hello')

Why might the client not receive the broadcast?

A The client is subscribed to a different channel name due to case sensitivity mismatch.

B The broadcast message format is incorrect and must be a string, not a hash.

C The subscription method should use <code>stream_for</code> instead of <code>stream_from</code>.

D The channel class name must match the stream name exactly.

💡 Hint

Check the exact string used in stream_from and in the broadcast call.

Action Cable channel names are case sensitive. The subscription streams from 'chat_channel' (lowercase), and the broadcast uses 'chat_channel' (lowercase) so they match. If there was a case mismatch, the client would not receive the broadcast.

❓ state_output

advanced

What is the state of the connection after disconnecting in Action Cable?

In an Action Cable connection, what happens to the connection object state after the client disconnects?

A The connection object is destroyed and cannot be reused or referenced anymore.

B The connection object is closed but can be re-established automatically by the client.

C The connection object remains active and continues streaming data until server restart.

D The connection object is paused but keeps subscriptions alive on the server.

💡 Hint

Think about how WebSocket connections behave on disconnect and reconnect.

When a client disconnects, the connection is closed but the client can reconnect automatically, establishing a new connection object.

🧠 Conceptual

expert

How does Action Cable ensure real-time updates scale across multiple server instances?

In a production environment with multiple Rails server instances, how does Action Cable ensure that broadcasts reach all subscribed clients regardless of which server instance they are connected to?

A Action Cable uses a Redis pub/sub adapter to broadcast messages across all server instances.

B Action Cable duplicates WebSocket connections to all servers to send messages simultaneously.

C Action Cable stores all messages in the database and clients poll for updates regularly.

D Action Cable requires sticky sessions so clients always connect to the same server instance.

💡 Hint

Consider how messages are shared between servers in a distributed system.

Action Cable uses Redis as a pub/sub backend to broadcast messages to all server instances, ensuring all clients receive updates regardless of which server they connect to.

Practice

1. What is the main purpose of Action Cable in a Rails application?

easy

A. To add real-time features allowing live updates without page reloads

B. To manage database migrations automatically

C. To handle background jobs and scheduling

D. To style the application with CSS frameworks

Solution

1. Step 1: Understand Action Cable's role

   Action Cable integrates WebSockets into Rails to enable live, real-time communication.

2. Step 2: Compare options with Action Cable's purpose

   Only To add real-time features allowing live updates without page reloads describes real-time updates without page reloads, which is what Action Cable does.

3. Final Answer:

   To add real-time features allowing live updates without page reloads -> Option A

4. Quick Check:

   Real-time updates = To add real-time features allowing live updates without page reloads [OK]

Hint: Remember: Action Cable = live updates without refreshing [OK]

Common Mistakes:

• Confusing Action Cable with background job tools
• Thinking it manages database tasks
• Assuming it styles the app

2. Which of the following is the correct way to create a channel subscription in a Rails JavaScript client using Action Cable?

easy

A. App.cable.subscriptions.create('ChatChannel')

B. App.cable.subscribe('ChatChannel')

C. App.cable.connect('ChatChannel')

D. App.cable.open('ChatChannel')

Solution

1. Step 1: Recall Action Cable subscription syntax

   The correct method to subscribe to a channel is using subscriptions.create.

2. Step 2: Match options with correct method

   Only App.cable.subscriptions.create('ChatChannel') uses subscriptions.create('ChatChannel'), which is the correct syntax.

3. Final Answer:

   App.cable.subscriptions.create('ChatChannel') -> Option A

4. Quick Check:

   Subscription method = subscriptions.create [OK]

Hint: Use subscriptions.create to subscribe to channels [OK]

Common Mistakes:

• Using subscribe instead of subscriptions.create
• Using connect or open which are invalid methods
• Missing quotes around channel name

3. Given this channel code in Rails:

class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from 'chat_room'
  end
end

And this JavaScript subscription:

App.cable.subscriptions.create('ChatChannel', {
  received(data) {
    console.log(data.message)
  }
})

What will happen when the server broadcasts { message: 'Hello!' } to 'chat_room'?

medium

A. Nothing will happen because the channel name is incorrect

B. The message 'Hello!' will be logged in the browser console

C. The message will be displayed as an alert popup

D. The server will throw an error due to missing perform method

Solution

1. Step 1: Understand the channel subscription and streaming

   The channel streams from 'chat_room', and the client subscribes to 'ChatChannel' with a received callback logging data.message.

2. Step 2: Analyze the broadcast effect

   When the server broadcasts { message: 'Hello!' } to 'chat_room', the client receives it and logs 'Hello!' to the console.

3. Final Answer:

   The message 'Hello!' will be logged in the browser console -> Option B

4. Quick Check:

   Broadcast to stream triggers received callback = The message 'Hello!' will be logged in the browser console [OK]

Hint: Broadcast to stream triggers received callback logging message [OK]

Common Mistakes:

• Confusing channel name with stream name
• Expecting alert instead of console log
• Thinking server errors without perform method

4. Identify the error in this Action Cable channel code:

class NotificationsChannel < ApplicationCable::Channel
  def subscribed
    stream_from notifications
  end
end

medium

A. The channel class should inherit from ApplicationController

B. The subscribed method is missing a call to reject unauthorized users

C. The stream_from argument should be a string, not a variable

D. The stream_from method is deprecated and should not be used

Solution

1. Step 1: Check the stream_from argument type

   The argument to stream_from must be a string representing the stream name, e.g., 'notifications'.

2. Step 2: Identify the error in the code

   The code uses notifications without quotes, treating it as a variable, which causes an error.

3. Final Answer:

   The stream_from argument should be a string, not a variable -> Option C

4. Quick Check:

   stream_from needs string argument [OK]

Hint: Always quote stream names in stream_from method [OK]

Common Mistakes:

• Forgetting quotes around stream name
• Inheriting from wrong class
• Assuming stream_from is deprecated

5. You want to broadcast a message to all users subscribed to 'notifications' channel whenever a new comment is created. Which code snippet correctly achieves this in Rails?

hard

A. ActionCable.broadcast('notifications', @comment.body)

B. NotificationsChannel.broadcast_to('notifications', { comment: @comment.body })

C. broadcast_to('notifications', { comment: @comment.body })

D. ActionCable.server.broadcast('notifications', { comment: @comment.body })

Solution

1. Step 1: Identify the correct broadcast method

   To send a message to all subscribers of a stream, use ActionCable.server.broadcast(stream, data).

2. Step 2: Analyze options for correct usage

   ActionCable.server.broadcast('notifications', { comment: @comment.body }) uses ActionCable.server.broadcast with stream name and data hash, which is correct.

3. Final Answer:

   ActionCable.server.broadcast('notifications', { comment: @comment.body }) -> Option D

4. Quick Check:

   Broadcast to stream uses ActionCable.server.broadcast [OK]

Hint: Use ActionCable.server.broadcast to send to all subscribers [OK]

Common Mistakes:

• Using broadcast_to without a model instance
• Calling broadcast on ActionCable directly
• Passing data without wrapping in a hash