cable_room 0.5.3 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53c8de0c99b0ff0da420563e56de1ee4069efdf7bd6f4a37e520fb4640cbd15
-  data.tar.gz: 626d3b5862dfe6dfae8c10769514d0a5021368babc19d4c1cee482d0135dc66b
+  metadata.gz: c3adda4804c009f6778b8c629dd3ee94393f8f9329e3472fd155795f4cf6f0ad
+  data.tar.gz: 586c39696ce02f18fe83e975e256023151d4e0af8ad6ae9e9a5bb5fdcc6ca829
 SHA512:
-  metadata.gz: 7f17acc99331147b65cd1b0be570739da5c9ea11a07bba0fc9539ba54e9a99a2647fb499c2366b81d5be7852dbdc1089ddc08369b7a2bb2d5773e810d9f24ee6
-  data.tar.gz: 25a4b95fec82b9311af21f9544697c71900a0ec112285e990b8024aec1be2902af60f5105c58af5ff4e627b21467e642f2713c9a8f91632347e94e688e07f4da
+  metadata.gz: 36485ec4fce091883958e09767761cb27cc83c3888c86220c182742a9c319bf9ac21a16f4e0878691bed0071537e7050d01351f7ff42d1401248e21df8788514
+  data.tar.gz: aae807731576843f3bcaf0f5f2b7b8da19229f1aac178c687b5191fc7b0852870e4704216ec37dcf8b7323232ff1c432ad3532cb2e19a836f028668106e9801b

data/lib/cable_room/room/input_handling.rb

@@ -57,7 +57,7 @@ module CableRoom
           ports[self.class::ROOM_IN_CHANNEL].stream do |message|
             begin
               Room.current_message = message
-              ActiveSupport::Notifications.instrument("message_received.cable_room", { room: self, message: m }) do
+              ActiveSupport::Notifications.instrument("message_received.cable_room", { room: self, message: message }) do
                 run_callbacks :receive_message do
                   handle_received_message(message)
                 end

data/lib/cable_room/room/port_management.rb

@@ -104,7 +104,7 @@ module CableRoom
       def handle_received_message(message)
         case message['type']
         when 'port_connected'
-          mo = @_port_clients[@current_message_origin] ||= PortClient.new(@current_message_origin)
+          mo = @_port_clients[@current_message_origin] ||= PortClient.new(self, @current_message_origin)
 
           mo.touch_activity!
           mo.tag!(message['tags'])
@@ -155,7 +155,8 @@ module CableRoom
       class PortClient
         attr_reader :token
 
-        def initialize(token)
+        def initialize(room, token)
+          @room = room
           @token = token
           @metadata = HashWithIndifferentAccess.new
           @metadata[:tags] = Set.new
@@ -164,6 +165,12 @@ module CableRoom
 
         delegate :[], :[]=, to: :@metadata
 
+        def <<(data)
+          @room.with_port_scope(client_port: @token) do
+            @room.broadcast(data)
+          end
+        end
+
         def merge!(value)
           @metadata.merge!(value || {})
         end

data/lib/cable_room/version.rb

@@ -1,3 +1,3 @@
 module CableRoom
-  VERSION = "0.5.3".freeze
+  VERSION = "0.5.5".freeze
 end

data/spec/cable_room/e2e_room_spec.rb

@@ -0,0 +1,481 @@
+require "spec_helper"
+
+# E2E Integration Tests for CableRoom
+#
+# These tests use the async ActionCable adapter (configured in spec_helper.rb)
+# instead of the test adapter to enable real message delivery during tests.
+# This allows us to test actual end-to-end communication flow between rooms
+# and room members, rather than just verifying that broadcasts were sent.
+
+RSpec.describe "CableRoom E2E Integration", type: :channel do
+  # Setup a test room class for the e2e tests
+  class E2ETestRoom < CableRoom::Room::Base
+    cattr_accessor :events, default: []
+    cattr_accessor :latest_instance
+
+    after_startup do
+      self.class.latest_instance = self
+      self.class.events << { type: :room_started, key: key, timestamp: Time.current }
+      self << { type: "room_ready", message: "Room is now active" }
+    end
+
+    on_user_joined do
+      user_id = message_origin&.user
+      self.class.events << { type: :user_joined, user: user_id, key: key, timestamp: Time.current }
+      broadcast({ type: "user_joined_broadcast", user: user_id })
+    end
+
+    on_user_left do
+      user_id = message_origin&.user
+      self.class.events << { type: :user_left, user: user_id, key: key, timestamp: Time.current }
+      broadcast({ type: "user_left_broadcast", user: user_id })
+    end
+
+    before_shutdown do
+      self.class.events << { type: :room_shutting_down, key: key, timestamp: Time.current }
+    end
+
+    after_shutdown do
+      self.class.events << { type: :room_shutdown, key: key, timestamp: Time.current }
+    end
+
+    # Custom message handlers
+    def on_custom_message(msg)
+      self.class.events << { type: :custom_message_received, data: msg['data'], key: key }
+      broadcast({ type: "custom_response", original: msg['data'], processed: true })
+    end
+
+    def on_request_info(msg)
+      message_origin << { type: "room_info", key: key, users: connected_users.count }
+    end
+  end
+
+  # Setup a test channel for users to join rooms
+  class E2ETestChannel < ApplicationCable::Channel
+    include CableRoom::RoomMember
+
+    attr_reader :room, :received_messages
+
+    def initialize(*)
+      super
+      @received_messages = []
+    end
+
+    def current_user
+      params[:user_id]
+    end
+
+    def subscribed
+      key = params[:room_key] || SecureRandom.hex(8)
+
+      @room = join_room(
+        E2ETestRoom,
+        key,
+        create: params[:create] || false,
+        tags: params[:tags] || [],
+        as: current_user,
+        on_joined: ->(membership) {
+          @received_messages << { type: :on_joined_callback, timestamp: Time.current }
+        },
+        on_room_opened: ->(membership) {
+          @received_messages << { type: :on_room_opened_callback, timestamp: Time.current }
+        },
+        on_room_closed: ->(membership) {
+          @received_messages << { type: :on_room_closed_callback, timestamp: Time.current }
+        },
+        on_message: ->(message) {
+          @received_messages << { type: :on_message_callback, message: message, timestamp: Time.current }
+        }
+      )
+    end
+
+    def unsubscribed
+      @room&.leave!
+    end
+
+    def send_custom_message(data)
+      @room << { type: 'custom_message', data: data }
+    end
+
+    def request_room_info
+      @room << { type: 'request_info' }
+    end
+  end
+
+  class ConnStub < ::ActionCable::Channel::ConnectionStub
+    delegate :worker_pool, :logger, to: :server
+    def initialize(...)
+      super
+    end
+  end
+
+  module ChannelStub
+    def confirmed?
+      subscription_confirmation_sent?
+    end
+
+    def rejected?
+      subscription_rejected?
+    end
+
+    def streams; super; end
+
+    # def stream_from(broadcasting, *)
+    #   super
+    #   # streams << broadcasting
+    # end
+
+    # def stream_from(broadcasting, callback = nil, coder: nil, &block)
+    #   broadcasting = String(broadcasting)
+
+    #   # Don't send the confirmation until pubsub#subscribe is successful
+    #   defer_subscription_confirmation!
+
+    #   # Build a stream handler by wrapping the user-provided callback with a decoder
+    #   # or defaulting to a JSON-decoding retransmitter.
+    #   handler = worker_pool_stream_handler(broadcasting, callback || block, coder: coder)
+    #   streams << broadcasting
+
+    #   connection.server.event_loop.post do
+    #     pubsub.subscribe(broadcasting, handler, lambda do
+    #       ensure_confirmation_sent
+    #       logger.info "#{self.class.name} is streaming from #{broadcasting}"
+    #     end)
+    #   end
+    # end
+
+    # def stop_all_streams
+    #   @_streams = []
+    # end
+
+    # def streams
+    #   @_streams ||= []
+    # end
+  end
+
+  def subscribe(params={})
+    @connection ||= stub_connection
+    @subscription = self.class.channel_class.new(connection, "test_stub", params.with_indifferent_access)
+    @subscription.singleton_class.include(ChannelStub)
+    @subscription.subscribe_to_channel
+    @subscription
+  end
+
+  before(:each) do
+    @connection = ConnStub.new
+  end
+
+  describe E2ETestChannel, type: :channel do
+    let(:room_key) { "e2e-test-#{SecureRandom.hex(4)}" }
+
+    before(:each) do
+      E2ETestRoom.events.clear
+      E2ETestRoom.latest_instance = nil
+    end
+
+    describe "Room Creation and Lifecycle" do
+    it "creates a room when a user connects with create: true" do
+      expect {
+        subscribe(room_key: room_key, create: true, user_id: "user1")
+      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(1)
+
+      expect(subscription).to be_confirmed
+      expect(E2ETestRoom.events).to include(hash_including(type: :room_started, key: room_key))
+    end
+
+    it "does not create a room when create: false" do
+      expect {
+        subscribe(room_key: room_key, create: false, user_id: "user1")
+      }.not_to change { CableRoom::ChannelTracker.instance.room_channels.count }
+    end
+
+    it "properly shuts down a room when sent KILL message" do
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+
+      initial_count = CableRoom::ChannelTracker.instance.room_channels.count
+
+      E2ETestRoom.send_message(room_key, "KILL", port: :to_room)
+      sleep 0.2 # Give time for shutdown to complete
+
+      expect(CableRoom::ChannelTracker.instance.room_channels.count).to eq(initial_count - 1)
+      expect(E2ETestRoom.events).to include(hash_including(type: :room_shutdown, key: room_key))
+    end
+  end
+
+  describe "Port Connections" do
+    it "establishes proper port connections for room communication" do
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+
+      # Verify the expected streams are opened
+      expect(subscription.streams.keys).to include(/E2ETestRoom:.*:from_room/)
+      expect(subscription.streams.keys).to include(/E2ETestRoom:.*:[0-9a-f]{32}/) # Token-based port
+    end
+
+    it "creates separate port streams for different users" do
+      # First user subscribes
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      first_subscription = subscription
+
+      # Second user subscribes to same room
+      subscribe(room_key: room_key, create: false, user_id: "user2")
+      second_subscription = subscription
+
+      # Should have the shared broadcast stream
+      expect(first_subscription.streams.keys).to include(/E2ETestRoom:.*:from_room/)
+      expect(second_subscription.streams.keys).to include(/E2ETestRoom:.*:from_room/)
+    end
+
+    it "supports tagged ports for selective broadcasting" do
+      subscribe(room_key: room_key, create: true, user_id: "user1", tags: ["admin", "moderator"])
+
+      # Give time for connection to establish
+      sleep 0.1
+
+      # User should be listening to tagged ports
+      room = E2ETestRoom.latest_instance
+      expect(room).not_to be_nil
+    end
+  end
+
+  describe "User Joining and Leaving" do
+    it "properly handles a user joining the room" do
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+
+      # Give time for join callbacks to fire
+      sleep 0.1
+
+      expect(E2ETestRoom.events).to include(hash_including(type: :user_joined, user: "user1"))
+      expect(subscription.received_messages).to include(hash_including(type: :on_joined_callback))
+    end
+
+    it "handles multiple users joining the same room" do
+      # First user joins and creates room
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      sleep 0.1
+
+      first_user_count = E2ETestRoom.events.count { |e| e[:type] == :user_joined }
+
+      # Second user joins existing room
+      subscribe(room_key: room_key, create: false, user_id: "user2")
+      sleep 0.1
+
+      # Should have two user_joined events
+      expect(E2ETestRoom.events.count { |e| e[:type] == :user_joined }).to eq(first_user_count + 1)
+
+      # Verify both users are tracked
+      expect(E2ETestRoom.events.map { |e| e[:user] if e[:type] == :user_joined }.compact).to include("user1", "user2")
+    end
+
+    it "properly handles a user leaving the room" do
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      sleep 0.1
+
+      # User leaves
+      unsubscribe
+      sleep 0.1
+
+      expect(E2ETestRoom.events).to include(hash_including(type: :user_left, user: "user1"))
+    end
+
+    it "handles same user connecting from multiple ports" do
+      # Same user subscribes twice (e.g., multiple browser tabs)
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      first_subscription = subscription
+      sleep 0.1
+
+      initial_join_count = E2ETestRoom.events.count { |e| e[:type] == :user_joined }
+
+      subscribe(room_key: room_key, create: false, user_id: "user1")
+      sleep 0.1
+
+      # Should only trigger one user_joined event (same user)
+      expect(E2ETestRoom.events.count { |e| e[:type] == :user_joined }).to eq(initial_join_count)
+
+      # Close one connection
+      first_subscription.unsubscribe_from_channel
+      sleep 0.1
+
+      # User should not have left yet (still has one connection)
+      final_left_count = E2ETestRoom.events.count { |e| e[:type] == :user_left && e[:user] == "user1" }
+      expect(final_left_count).to eq(0)
+    end
+  end
+
+  describe "Message Broadcasting and Communication" do
+    it "broadcasts messages to all connected users" do
+      # Two users join
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      user1 = subscription
+      sleep 0.1
+
+      subscribe(room_key: room_key, create: false, user_id: "user2")
+      user2 = subscription
+      sleep 0.1
+
+      # User 1 sends a custom message
+      user1.send_custom_message({ text: "Hello everyone!" })
+      sleep 0.1
+
+      # Both users should receive the broadcast response
+      expect(user1.received_messages).to include(
+        hash_including(
+          type: :on_message_callback,
+          message: hash_including("type" => "custom_response", "processed" => true)
+        )
+      )
+      expect(user2.received_messages).to include(
+        hash_including(
+          type: :on_message_callback,
+          message: hash_including("type" => "custom_response", "processed" => true)
+        )
+      )
+
+      # Room should have recorded the custom message
+      expect(E2ETestRoom.events).to include(
+        hash_including(type: :custom_message_received, data: { "text" => "Hello everyone!" })
+      )
+    end
+
+    it "supports direct messaging to specific users via their port" do
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      user1 = subscription
+      sleep 0.1
+
+      subscribe(room_key: room_key, create: false, user_id: "user2")
+      user2 = subscription
+      sleep 0.1
+
+      # User 2 requests room info (should get private response)
+      user2.request_room_info
+      sleep 0.1
+
+      # User 2 should receive room info
+      expect(user2.received_messages).to include(
+        hash_including(
+          type: :on_message_callback,
+          message: hash_including("type" => "room_info")
+        )
+      )
+    end
+  end
+
+  describe "Complete E2E Flow" do
+    it "handles full lifecycle: create, multiple users join/leave, messages, shutdown" do
+      # Step 1: First user creates room
+      subscribe(room_key: room_key, create: true, user_id: "alice")
+      alice = subscription
+      sleep 0.1
+
+      expect(CableRoom::ChannelTracker.instance.room_channels.count).to be > 0
+      expect(E2ETestRoom.events).to include(hash_including(type: :room_started))
+      expect(E2ETestRoom.events).to include(hash_including(type: :user_joined, user: "alice"))
+
+      # Step 2: Second user joins
+      subscribe(room_key: room_key, create: false, user_id: "bob")
+      bob = subscription
+      sleep 0.1
+
+      expect(E2ETestRoom.events).to include(hash_including(type: :user_joined, user: "bob"))
+
+      # Step 3: Third user joins
+      subscribe(room_key: room_key, create: false, user_id: "charlie")
+      charlie = subscription
+      sleep 0.1
+
+      expect(E2ETestRoom.events).to include(hash_including(type: :user_joined, user: "charlie"))
+
+      # Step 4: Users exchange messages
+      alice.send_custom_message({ from: "alice", text: "Hello room!" })
+      sleep 0.1
+
+      bob.send_custom_message({ from: "bob", text: "Hi alice!" })
+      sleep 0.1
+
+      # All users should have received broadcasts
+      expect(alice.received_messages.count { |m| m[:type] == :on_message_callback && m[:message]["type"] == "custom_response" }).to eq(2)
+      expect(bob.received_messages.count { |m| m[:type] == :on_message_callback && m[:message]["type"] == "custom_response" }).to eq(2)
+      expect(charlie.received_messages.count { |m| m[:type] == :on_message_callback && m[:message]["type"] == "custom_response" }).to eq(2)
+
+      # Step 5: One user leaves
+      bob.unsubscribe_from_channel
+      sleep 0.1
+
+      expect(E2ETestRoom.events).to include(hash_including(type: :user_left, user: "bob"))
+
+      # Step 6: Another message is sent (bob shouldn't receive it)
+      bob_message_count_before = bob.received_messages.count
+      alice.send_custom_message({ from: "alice", text: "Bob left!" })
+      sleep 0.1
+
+      expect(bob.received_messages.count).to eq(bob_message_count_before) # No new messages for bob
+      expect(charlie.received_messages.count { |m| m[:type] == :on_message_callback && m[:message]["type"] == "custom_response" }).to eq(3)
+
+      # Step 7: Shutdown the room
+      room_count_before = CableRoom::ChannelTracker.instance.room_channels.count
+      E2ETestRoom.send_message(room_key, "KILL", port: :to_room)
+      sleep 0.2
+
+      # Room should be shut down
+      expect(CableRoom::ChannelTracker.instance.room_channels.count).to eq(room_count_before - 1)
+      expect(E2ETestRoom.events).to include(hash_including(type: :room_shutting_down))
+      expect(E2ETestRoom.events).to include(hash_including(type: :room_shutdown))
+
+      # Users should receive room_closed notifications
+      expect(alice.received_messages).to include(hash_including(type: :on_room_closed_callback))
+      expect(charlie.received_messages).to include(hash_including(type: :on_room_closed_callback))
+    end
+  end
+
+  describe "Room Reaping and Idle Timeout" do
+    it "automatically shuts down idle rooms" do
+      subscribe(room_key: room_key, create: true, user_id: "user1")
+      room = E2ETestRoom.latest_instance
+      vchan = room.instance_variable_get(:@cable_channel)
+
+      unsubscribe
+      sleep 0.1
+
+      # Room should still exist (hasn't timed out yet)
+      expect(CableRoom::ChannelTracker.instance.room_channels).to include(vchan)
+
+      # Simulate watchdog timeout
+      vchan.instance_variable_set(:@last_watchdog_ping_at, 2.hours.ago)
+
+      room_count_before = CableRoom::ChannelTracker.instance.room_channels.count
+      vchan.send(:check_room_watchdog)
+      sleep 0.2
+
+      # Room should be reaped
+      expect(CableRoom::ChannelTracker.instance.room_channels.count).to eq(room_count_before - 1)
+      expect(E2ETestRoom.events).to include(hash_including(type: :room_shutdown))
+    end
+  end
+
+  describe "Concurrent Room Operations" do
+    it "handles multiple rooms simultaneously" do
+      room1_key = "concurrent-room-1-#{SecureRandom.hex(4)}"
+      room2_key = "concurrent-room-2-#{SecureRandom.hex(4)}"
+
+      # Create two separate rooms
+      subscribe(room_key: room1_key, create: true, user_id: "user1")
+      room1_sub = subscription
+      sleep 0.1
+
+      subscribe(room_key: room2_key, create: true, user_id: "user2")
+      room2_sub = subscription
+      sleep 0.1
+
+      # Both rooms should exist
+      expect(E2ETestRoom.events.count { |e| e[:type] == :room_started }).to be >= 2
+
+      # Send messages in both rooms
+      room1_sub.send_custom_message({ room: "room1" })
+      room2_sub.send_custom_message({ room: "room2" })
+      sleep 0.1
+
+      # Each room should have processed its own message
+      expect(E2ETestRoom.events.count { |e| e[:type] == :custom_message_received }).to eq(2)
+    end
+  end
+  end
+end

data/spec/internal/config/cable.yml

@@ -1,2 +1,2 @@
 test:
-  adapter: test
+  adapter: async