cable_room 0.5.5 → 0.6.0

data/spec/cable_room/e2e_room_spec.rb

@@ -1,481 +0,0 @@
-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/cable_room/room_member_spec.rb

@@ -1,113 +0,0 @@
-require "spec_helper"
-
-RSpec.describe CableRoom::RoomMember do
-  RUN_KEY = SecureRandom.hex(8)
-
-  class TestRoom < CableRoom::Room::Base
-    cattr_accessor :latest_instance
-
-    after_startup do
-      self.class.latest_instance = self
-      self << { type: "custom_started" }
-    end
-
-    before_shutdown do
-
-    end
-  end
-
-  class TestChannel < ApplicationCable::Channel
-    include CableRoom::RoomMember
-
-    attr_reader :room
-
-    def subscribed
-      key = RUN_KEY + (params[:key] || SecureRandom.hex(8))
-      @room = join_room(TestRoom, key, create: params[:create])
-    end
-
-    def unsubscribed
-      @room.leave!
-    end
-  end
-
-  describe TestChannel, type: :channel do
-    before do
-      stub_connection current_user: nil
-    end
-
-    it "provisions a room if it doesn't exist" do
-      expect {
-        subscribe create: true
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(1)
-      unsubscribe
-    end
-
-    it "opens the expected streams" do
-      key = 'ABC'
-      subscribe key:, create: true
-      expect(subscription).to be_confirmed
-      expect(subscription).to have_stream_from(/TestRoom:\w+ABC:from_room/)
-      expect(subscription).to have_stream_from(/TestRoom:\w+ABC:\w+/)
-      unsubscribe
-    end
-
-    it "does not provision a room if `create: false`" do
-      expect {
-        subscribe create: false
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(0)
-    end
-
-    it "does not provision a duplicate room" do
-      key = SecureRandom.hex(8)
-      expect {
-        subscribe key: key, create: true
-        subscribe key: key, create: true
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(1)
-      unsubscribe
-    end
-
-    it "can provision multiple rooms" do
-      expect {
-        subscribe key: 'A', create: true
-        subscribe key: 'B', create: true
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(2)
-      unsubscribe
-    end
-
-    it "does not shutdown immediately on unsubscribe" do
-      subscribe create: true
-      expect {
-        unsubscribe
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(0)
-    end
-
-    it "shuts down when the room receives a KILL message" do
-      subscribe create: true
-      expect {
-        room = subscription.room
-        TestRoom.send_message(room.key, "KILL", port: :to_room)
-        sleep 0.1
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(-1)
-    end
-
-    it "shuts down when the room is idle" do
-      subscribe create: true
-      unsubscribe
-
-      room = TestRoom.latest_instance
-      vchan = room.instance_variable_get(:@cable_channel)
-      expect {
-        room.send(:ping_watchdog)
-        vchan.send(:check_room_watchdog)
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(0)
-
-      vchan.instance_variable_set(:@last_watchdog_ping_at, 1.hour.ago)
-
-      expect {
-        vchan.send(:check_room_watchdog)
-        sleep 0.1
-      }.to change { CableRoom::ChannelTracker.instance.room_channels.count }.by(-1)
-    end
-  end
-end

data/spec/internal/config/cable.yml

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

data/spec/internal/config/database.yml

@@ -1,5 +0,0 @@
-test:
-  database: cable-room-test
-  adapter: postgresql
-  encoding: unicode
-  pool: 15

data/spec/internal/config/routes.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-Rails.application.routes.draw do
-  # Add your own routes here, or remove this file if you don't have need for it.
-end

data/spec/internal/config/storage.yml

@@ -1,3 +0,0 @@
-test:
-  service: Disk
-  root: /Users/eknapp/code/CableRoom/tmp/storage

data/spec/internal/db/schema.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-ActiveRecord::Schema.define do
-  # Set up any tables you need to exist for your test suite that don't belong
-  # in migrations.
-end