How to test LiteCable broadcasting from irb console? - ruby

Question

Actually my question is not about console only. I haven't found any libraries for testing LiteCable, and I try to implement some. The problem I faced now, is when I call in console something like (exactly same as official example):
LiteCable.broadcast "chat_#{chat_id}", user: user, message: data["message"], sid: sid
It returns nil. I've tried to put byebug in the code, and when I call this method with absolutely same parameters there, I got pretty big sheet with some unreadable parameters. And the main problem is I don't see messages I try to send from console.
Can someone explain why is that and how can I implement sending requests from console? The point is I working on api-only application, and try to cover this functionality with proper tests. Thank you very much in advance!
P.S: the project is on pure ruby, without rails

Answer 1

Since you don't have the entire code, I am unable to get a clear sense of your setup. The default broadcast_adapter for LiteCable is memory, so if you were to broadcast from your console, processes outside your console will not receive such streams. If you use the anycable adapter which I believe queues broadcasts in redis, then you should be able to broadcast from your console provided you have the correct connection.
Here is a simple implementation of a WS client and a server using LiteCable without Rails
# ~/app/server.rb
# A simple WS server that evaluates math expression literally using ruby eval
# Run this server with ruby server.rb
require "rack"
require "rack/handler/puma"
require "lite_cable"
require "lite_cable/server"
class CalculatorConnection < LiteCable::Connection::Base
identified_by :token
def connect
self.token = request.params["token"]
$stdout.puts "Session #{token} is connected to the server"
end
def disconnect
$stdout.puts "Session #{token} disconnected from the server"
end
end
class CalculatorChannel < LiteCable::Channel::Base
identifier :calculator
def subscribed
stream_from "calculator"
end
def evaluate(payload)
$stdout.puts "Data received from the client"
LiteCable.broadcast "calculator", result: eval(payload['expression'])
end
end
app = Rack::Builder.new
app.map "/cable" do
use LiteCable::Server::Middleware, connection_class: CalculatorConnection
run(proc { |_| [200, {"Content-Type" => "text/plain"}, ["OK"]] })
end
Rack::Handler::Puma.run app
// ~/app/client.js
// A client that talks to the WS server.
// To run, Open chrome console and paste this code
let socket = null;
(function init() {
socket = new WebSocket("ws://0.0.0.0:9292/cable?token=abc123");
socket.onopen = function (e) {
console.info("[connected] : Connection established to the server");
};
socket.onmessage = function (e) {
console.info("[message] : Message from the server", e.data);
};
socket.onerror = function (e) {
console.error("[error] : Error establishing connection", e.message);
};
})();
// subscribe to the calculator channel
socket.send(
JSON.stringify({
command: "subscribe",
identifier: JSON.stringify({
channel: "calculator",
}),
})
);
// call the evaluate method on the Calculator channel
socket.send(
JSON.stringify({
command: "message",
identifier: JSON.stringify({
channel: "calculator",
}),
data: JSON.stringify({
expression: "150 * 4 - 3 / (2 + 2)",
action: "evaluate",
}),
})
);
There's nothing special going on here just a simple rack app that uses Puma which adds support for rack socket hijacking. This should guide you in the right direction. Make sure you keep both your server and chrome console open to see the output. Try sending additional message to the server to see the output.
If you are looking at implementing a WebSocket client in ruby instead of js using LiteCable, check the client socket class in the LiteCable repo