togglecraft 1.0.0

data/spec/togglecraft/shared_sse_connection_spec.rb

@@ -0,0 +1,585 @@
+# frozen_string_literal: true
+
+RSpec.describe ToggleCraft::SharedSSEConnection do
+  let(:config) do
+    {
+      url: 'https://test.togglecraft.io',
+      sdk_key: 'test-key-123',
+      reconnect_interval: 0.1,
+      max_reconnect_interval: 0.5,
+      heartbeat_interval: 1,
+      debug: false
+    }
+  end
+  let(:pool_key) { 'test-pool-key' }
+  let(:shared_connection) { described_class.new(config, pool_key) }
+
+  # Mock client that responds to callbacks
+  let(:mock_client) do
+    double('Client',
+           handle_connect: nil,
+           handle_flags_update: nil,
+           handle_disconnect: nil,
+           handle_error: nil,
+           emit: nil,
+           respond_to?: true)
+  end
+
+  after do
+    shared_connection.force_disconnect if shared_connection
+  end
+
+  describe '#initialize' do
+    it 'stores config and pool_key' do
+      expect(shared_connection.pool_key).to eq(pool_key)
+      expect(shared_connection.instance_variable_get(:@config)).to eq(config)
+    end
+
+    it 'initializes clients set' do
+      clients = shared_connection.instance_variable_get(:@clients)
+      expect(clients).to be_a(Concurrent::Set)
+      expect(clients).to be_empty
+    end
+
+    it 'initializes state variables' do
+      expect(shared_connection.instance_variable_get(:@connection)).to be_nil
+      expect(shared_connection.instance_variable_get(:@last_payload)).to be_nil
+      expect(shared_connection.instance_variable_get(:@is_connecting).value).to be false
+      expect(shared_connection.instance_variable_get(:@connection_promise)).to be_nil
+    end
+
+    it 'sets debug flag from config' do
+      debug_conn = described_class.new(config.merge(debug: true), pool_key)
+      expect(debug_conn.instance_variable_get(:@debug)).to be true
+      debug_conn.force_disconnect
+    end
+  end
+
+  describe '#add_client' do
+    it 'adds client to clients set' do
+      shared_connection.add_client(mock_client)
+
+      clients = shared_connection.instance_variable_get(:@clients)
+      expect(clients).to include(mock_client)
+      expect(shared_connection.client_count).to eq(1)
+    end
+
+    it 'accepts multiple clients' do
+      client1 = double('Client1')
+      client2 = double('Client2')
+
+      shared_connection.add_client(client1)
+      shared_connection.add_client(client2)
+
+      expect(shared_connection.client_count).to eq(2)
+    end
+
+    it 'does not duplicate clients' do
+      shared_connection.add_client(mock_client)
+      shared_connection.add_client(mock_client)
+
+      expect(shared_connection.client_count).to eq(1)
+    end
+
+    context 'when connection is already established' do
+      before do
+        # Simulate established connection
+        connection = double('SSEConnection', connected?: true, disconnect: nil)
+        shared_connection.instance_variable_set(:@connection, connection)
+        shared_connection.instance_variable_set(:@last_payload, { flags: { 'test' => {} } })
+      end
+
+      it 'simulates connection event for new client' do
+        expect(mock_client).to receive(:handle_connect)
+        shared_connection.add_client(mock_client)
+      end
+
+      it 'sends cached flags to new client' do
+        expect(mock_client).to receive(:handle_flags_update).with({ flags: { 'test' => {} } })
+        shared_connection.add_client(mock_client)
+      end
+
+      it 'does not send flags if client does not respond to handle_flags_update' do
+        basic_client = double('BasicClient', respond_to?: false)
+        expect(basic_client).not_to receive(:handle_flags_update)
+        shared_connection.add_client(basic_client)
+      end
+    end
+  end
+
+  describe '#remove_client' do
+    before do
+      shared_connection.add_client(mock_client)
+    end
+
+    it 'removes client from clients set' do
+      shared_connection.remove_client(mock_client)
+
+      clients = shared_connection.instance_variable_get(:@clients)
+      expect(clients).not_to include(mock_client)
+      expect(shared_connection.client_count).to eq(0)
+    end
+
+    it 'handles removing non-existent client gracefully' do
+      other_client = double('OtherClient')
+      expect { shared_connection.remove_client(other_client) }.not_to raise_error
+    end
+
+    context 'when last client is removed' do
+      it 'triggers empty callback' do
+        callback_called = false
+        shared_connection.on_empty { callback_called = true }
+
+        shared_connection.remove_client(mock_client)
+
+        expect(callback_called).to be true
+      end
+
+      it 'calls cleanup method' do
+        expect(shared_connection).to receive(:cleanup).and_call_original
+
+        shared_connection.remove_client(mock_client)
+      end
+    end
+
+    context 'when other clients remain' do
+      before do
+        client2 = double('Client2')
+        shared_connection.add_client(client2)
+      end
+
+      it 'does not trigger empty callback' do
+        callback_called = false
+        shared_connection.on_empty { callback_called = true }
+
+        shared_connection.remove_client(mock_client)
+
+        expect(callback_called).to be false
+      end
+    end
+  end
+
+  describe '#connect' do
+    it 'creates new SSE connection' do
+      allow(shared_connection).to receive(:create_connection)
+      shared_connection.connect
+
+      expect(shared_connection).to have_received(:create_connection)
+    end
+
+    it 'adds client when provided' do
+      allow(shared_connection).to receive(:create_connection)
+
+      shared_connection.connect(mock_client)
+
+      expect(shared_connection.client_count).to eq(1)
+    end
+
+    it 'sets is_connecting flag during connection' do
+      original_create = shared_connection.method(:create_connection)
+
+      allow(shared_connection).to receive(:create_connection) do
+        # Check flag is set during connection
+        expect(shared_connection.instance_variable_get(:@is_connecting).value).to be true
+        original_create.call
+      end
+
+      shared_connection.connect
+    end
+
+    it 'clears is_connecting flag after connection' do
+      shared_connection.connect
+
+      expect(shared_connection.instance_variable_get(:@is_connecting).value).to be false
+    end
+
+    context 'when already connected' do
+      before do
+        connection = double('SSEConnection', connected?: true, connect: nil, disconnect: nil)
+        shared_connection.instance_variable_set(:@connection, connection)
+      end
+
+      it 'does not create new connection' do
+        expect(shared_connection).not_to receive(:create_connection)
+        shared_connection.connect
+      end
+
+      it 'adds client if provided' do
+        shared_connection.connect(mock_client)
+        expect(shared_connection.client_count).to eq(1)
+      end
+    end
+
+    context 'when connection is in progress' do
+      it 'waits instead of creating duplicate connection' do
+        # Simulate connection in progress
+        shared_connection.instance_variable_get(:@is_connecting).make_true
+
+        expect(shared_connection).not_to receive(:create_connection)
+        shared_connection.connect(mock_client)
+
+        # Should still add the client
+        expect(shared_connection.client_count).to eq(1)
+      end
+    end
+  end
+
+  describe '#disconnect' do
+    it 'calls disconnect on underlying connection when present' do
+      connection = double('SSEConnection', connect: nil, disconnect: nil)
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      expect(connection).to receive(:disconnect).at_least(:once)
+      shared_connection.disconnect
+    end
+
+    it 'does not raise error when connection is nil' do
+      shared_connection.instance_variable_set(:@connection, nil)
+
+      expect { shared_connection.disconnect }.not_to raise_error
+    end
+  end
+
+  describe '#force_disconnect' do
+    it 'disconnects connection' do
+      connection = double('SSEConnection', connect: nil, disconnect: nil)
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      expect(connection).to receive(:disconnect)
+      shared_connection.force_disconnect
+    end
+
+    it 'clears all clients' do
+      shared_connection.add_client(mock_client)
+      shared_connection.add_client(double('Client2'))
+
+      shared_connection.force_disconnect
+
+      expect(shared_connection.client_count).to eq(0)
+    end
+  end
+
+  describe '#reconnect' do
+    it 'notifies all clients about reconnection' do
+      shared_connection.add_client(mock_client)
+
+      expect(mock_client).to receive(:emit).with(:reconnecting)
+      shared_connection.reconnect
+    end
+
+    it 'calls reconnect on existing connection' do
+      connection = double('SSEConnection', connect: nil, reconnect: nil, disconnect: nil)
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      expect(connection).to receive(:reconnect)
+      shared_connection.reconnect
+    end
+
+    it 'creates new connection if none exists' do
+      shared_connection.instance_variable_set(:@connection, nil)
+
+      expect(shared_connection).to receive(:connect)
+      shared_connection.reconnect
+    end
+  end
+
+  describe '#connected?' do
+    it 'returns nil/falsey when no connection' do
+      # Clear connection first to avoid force_disconnect issues
+      shared_connection.instance_variable_set(:@connection, nil)
+
+      # Returns nil due to safe navigation operator
+      expect(shared_connection.connected?).to be_falsey
+    end
+
+    it 'delegates to connection when present' do
+      connection = double('SSEConnection', connected?: true, disconnect: nil)
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      expect(shared_connection.connected?).to be true
+    end
+  end
+
+  describe '#client_count' do
+    it 'returns 0 when no clients' do
+      expect(shared_connection.client_count).to eq(0)
+    end
+
+    it 'returns correct count with multiple clients' do
+      shared_connection.add_client(mock_client)
+      shared_connection.add_client(double('Client2'))
+      shared_connection.add_client(double('Client3'))
+
+      expect(shared_connection.client_count).to eq(3)
+    end
+  end
+
+  describe '#on_empty' do
+    it 'registers callback' do
+      callback = -> { }
+      shared_connection.on_empty(&callback)
+
+      expect(shared_connection.instance_variable_get(:@on_empty_callback)).to eq(callback)
+    end
+
+    it 'replaces previous callback' do
+      callback1 = -> { }
+      callback2 = -> { }
+
+      shared_connection.on_empty(&callback1)
+      shared_connection.on_empty(&callback2)
+
+      expect(shared_connection.instance_variable_get(:@on_empty_callback)).to eq(callback2)
+    end
+  end
+
+  describe 'message broadcasting' do
+    before do
+      shared_connection.add_client(mock_client)
+    end
+
+    describe 'handle_message' do
+      it 'broadcasts message to all clients' do
+        client2 = double('Client2', handle_flags_update: nil, respond_to?: true)
+        shared_connection.add_client(client2)
+
+        payload = { flags: { 'test' => {} } }
+
+        expect(mock_client).to receive(:handle_flags_update).with(payload)
+        expect(client2).to receive(:handle_flags_update).with(payload)
+
+        shared_connection.send(:handle_message, payload)
+      end
+
+      it 'caches flags payload for late-joining clients' do
+        payload = { flags: { 'test-flag' => { enabled: true } } }
+
+        shared_connection.send(:handle_message, payload)
+
+        expect(shared_connection.instance_variable_get(:@last_payload)).to eq(payload)
+      end
+
+      it 'does not cache non-flags messages' do
+        payload = { type: 'heartbeat' }
+
+        shared_connection.send(:handle_message, payload)
+
+        expect(shared_connection.instance_variable_get(:@last_payload)).to be_nil
+      end
+
+      it 'handles errors in client callbacks gracefully' do
+        failing_client = double('FailingClient', respond_to?: true)
+        allow(failing_client).to receive(:handle_flags_update).and_raise('Client error')
+
+        shared_connection.add_client(failing_client)
+
+        payload = { flags: {} }
+
+        # Should not raise error despite client failure
+        expect { shared_connection.send(:handle_message, payload) }.not_to raise_error
+
+        # Other clients should still receive message
+        expect(mock_client).to have_received(:handle_flags_update).with(payload)
+      end
+
+      it 'skips clients that do not respond to handle_flags_update' do
+        non_responsive_client = double('NonResponsiveClient', respond_to?: false)
+        shared_connection.add_client(non_responsive_client)
+
+        payload = { flags: {} }
+
+        expect(non_responsive_client).not_to receive(:handle_flags_update)
+        shared_connection.send(:handle_message, payload)
+      end
+    end
+
+    describe 'handle_connect' do
+      it 'notifies all clients of connection' do
+        client2 = double('Client2', handle_connect: nil, respond_to?: true)
+        shared_connection.add_client(client2)
+
+        expect(mock_client).to receive(:handle_connect)
+        expect(client2).to receive(:handle_connect)
+
+        shared_connection.send(:handle_connect)
+      end
+
+      it 'handles errors in client callbacks gracefully' do
+        failing_client = double('FailingClient', respond_to?: true)
+        allow(failing_client).to receive(:handle_connect).and_raise('Error')
+
+        shared_connection.add_client(failing_client)
+
+        expect { shared_connection.send(:handle_connect) }.not_to raise_error
+      end
+    end
+
+    describe 'handle_disconnect' do
+      it 'notifies all clients of disconnection' do
+        client2 = double('Client2', handle_disconnect: nil, respond_to?: true)
+        shared_connection.add_client(client2)
+
+        expect(mock_client).to receive(:handle_disconnect)
+        expect(client2).to receive(:handle_disconnect)
+
+        shared_connection.send(:handle_disconnect)
+      end
+
+      it 'isolates errors between clients' do
+        failing_client = double('FailingClient', respond_to?: true)
+        allow(failing_client).to receive(:handle_disconnect).and_raise('Error')
+
+        client2 = double('Client2', handle_disconnect: nil, respond_to?: true)
+
+        shared_connection.add_client(failing_client)
+        shared_connection.add_client(client2)
+
+        # Should not raise despite one client failing
+        expect { shared_connection.send(:handle_disconnect) }.not_to raise_error
+
+        # Other clients should still be notified
+        expect(client2).to have_received(:handle_disconnect)
+      end
+    end
+
+    describe 'handle_error' do
+      it 'broadcasts error to all clients' do
+        client2 = double('Client2', handle_error: nil, respond_to?: true)
+        shared_connection.add_client(client2)
+
+        error = StandardError.new('Test error')
+
+        expect(mock_client).to receive(:handle_error).with(error)
+        expect(client2).to receive(:handle_error).with(error)
+
+        shared_connection.send(:handle_error, error)
+      end
+
+      it 'handles nested errors gracefully' do
+        failing_client = double('FailingClient', respond_to?: true)
+        allow(failing_client).to receive(:handle_error).and_raise('Nested error')
+
+        shared_connection.add_client(failing_client)
+
+        error = StandardError.new('Original error')
+
+        expect { shared_connection.send(:handle_error, error) }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#set_debug' do
+    it 'updates debug flag' do
+      shared_connection.set_debug(true)
+
+      expect(shared_connection.instance_variable_get(:@debug)).to be true
+    end
+
+    it 'propagates debug to existing connection' do
+      connection = double('SSEConnection', connect: nil, disconnect: nil)
+      options = { debug: false }
+      connection.instance_variable_set(:@options, options)
+
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      shared_connection.set_debug(true)
+
+      updated_options = connection.instance_variable_get(:@options)
+      expect(updated_options[:debug]).to be true
+    end
+
+    it 'does not raise error when connection is nil' do
+      shared_connection.instance_variable_set(:@connection, nil)
+
+      expect { shared_connection.set_debug(true) }.not_to raise_error
+    end
+  end
+
+  describe 'cleanup' do
+    it 'disconnects connection' do
+      connection = double('SSEConnection', connect: nil, disconnect: nil)
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      expect(connection).to receive(:disconnect)
+      shared_connection.send(:cleanup)
+    end
+
+    it 'clears connection reference' do
+      connection = double('SSEConnection', connect: nil, disconnect: nil)
+      shared_connection.instance_variable_set(:@connection, connection)
+
+      shared_connection.send(:cleanup)
+
+      expect(shared_connection.instance_variable_get(:@connection)).to be_nil
+    end
+
+    it 'clears cached payload' do
+      shared_connection.instance_variable_set(:@last_payload, { flags: {} })
+
+      shared_connection.send(:cleanup)
+
+      expect(shared_connection.instance_variable_get(:@last_payload)).to be_nil
+    end
+
+    it 'resets is_connecting flag' do
+      shared_connection.instance_variable_get(:@is_connecting).make_true
+
+      shared_connection.send(:cleanup)
+
+      expect(shared_connection.instance_variable_get(:@is_connecting).value).to be false
+    end
+
+    it 'clears connection promise' do
+      shared_connection.instance_variable_set(:@connection_promise, 'promise')
+
+      shared_connection.send(:cleanup)
+
+      expect(shared_connection.instance_variable_get(:@connection_promise)).to be_nil
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent client additions' do
+      clients = 20.times.map { |i| double("Client#{i}") }
+
+      threads = clients.map do |client|
+        Thread.new { shared_connection.add_client(client) }
+      end
+
+      threads.each(&:join)
+
+      expect(shared_connection.client_count).to eq(20)
+    end
+
+    it 'handles concurrent client removals' do
+      clients = 10.times.map { |i| double("Client#{i}") }
+      clients.each { |client| shared_connection.add_client(client) }
+
+      threads = clients.map do |client|
+        Thread.new { shared_connection.remove_client(client) }
+      end
+
+      threads.each(&:join)
+
+      expect(shared_connection.client_count).to eq(0)
+    end
+
+    it 'handles concurrent message broadcasts' do
+      call_count = Concurrent::AtomicFixnum.new(0)
+      client = double('Client', respond_to?: true)
+      allow(client).to receive(:handle_flags_update) { call_count.increment }
+
+      shared_connection.add_client(client)
+
+      threads = 10.times.map do
+        Thread.new do
+          shared_connection.send(:handle_message, { flags: {} })
+        end
+      end
+
+      threads.each(&:join)
+
+      expect(call_count.value).to eq(10)
+    end
+  end
+end