Refactor: Move disconnect test to stream_spec.rb for better organization

Moved the "stops producing when client disconnects" test from
react_on_rails_pro_helper_spec.rb to stream_spec.rb to follow the
established architectural pattern.

Why:
- stream_spec.rb contains all streaming behavior/concurrency tests
- helper_spec.rb is for Rails integration tests, not streaming behavior
- stream_spec.rb uses cleaner setup (setup_stream_test) without Rails mocking

Changes:
- Removed test from helper_spec.rb (Rails integration test file)
- Added test to stream_spec.rb in "Component streaming concurrency" block
- Simplified test to use existing setup_stream_test helper
- Updated test to account for TEMPLATE being first write
- Test now expects ["TEMPLATE", "A1"] instead of just counting chunks

Benefits:
- Consistent with existing architecture (all concurrency tests in one place)
- Simpler test setup (no Rails mocking complexity)
- Easier to find (streaming behavior tests are in stream_spec.rb)
- Net -16 lines of code

Verified: All 21 tests in stream_spec.rb pass, including the new test.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ihabadham

react_on_rails_pro/spec/dummy/spec/helpers/react_on_rails_pro_helper_spec.rb

@@ -514,63 +514,6 @@ def execute_stream_view_containing_react_components
         end
       end
 
-      it "stops producing when client disconnects" do
-        queue = Async::Queue.new
-        mock_request_and_response(queue)
-
-        # Simulate client disconnect by making stream.write raise IOError
-        call_count = 0
-        stream_closed = false
-        allow(mocked_stream).to receive(:write) do |chunk|
-          call_count += 1
-          if call_count == 2
-            stream_closed = true
-            raise IOError, "client disconnected"
-          end
-          written_chunks << chunk
-        end
-
-        # Update the closed? stub to check the stream_closed flag
-        allow(mocked_stream).to receive(:closed?) { stream_closed }
-
-        # Configure render_to_string to call stream_react_component
-        allow(self).to receive(:render_to_string) do
-          render_result = stream_react_component(component_name, props: props, **component_options)
-          <<-HTML
-            <div>
-              <h1>Header Rendered In View</h1>
-              #{render_result}
-            </div>
-          HTML
-        end
-
-        Sync do |parent|
-          parent.async do
-            stream_view_containing_react_components(template: template_path)
-          rescue IOError
-            # Expected - client disconnected
-          end
-
-          # Enqueue first chunk - should be written successfully
-          queue.enqueue(chunks[0])
-          sleep 0.05
-
-          # Enqueue second chunk - should trigger disconnect
-          queue.enqueue(chunks[1])
-          sleep 0.05
-
-          # Enqueue third chunk - should not be written (producer stopped)
-          queue.enqueue(chunks[2])
-          sleep 0.05
-
-          queue.close
-          sleep 0.05
-        end
-
-        # Should only have written the first chunk before disconnect
-        expect(written_chunks.count).to eq(1)
-        expect(mocked_stream).to have_received(:write).at_most(2).times
-      end
     end
 
     describe "#cached_stream_react_component", :caching do # rubocop:disable RSpec/MultipleMemoizedHelpers

react_on_rails_pro/spec/react_on_rails_pro/stream_spec.rb

@@ -486,5 +486,46 @@ def setup_stream_test(component_count: 2)
       gaps = write_timestamps.each_cons(2).map { |a, b| b - a }
       expect(gaps.all? { |gap| gap >= 0.04 }).to be true
     end
+
+    it "stops producing when client disconnects" do
+      queues, controller, stream = setup_stream_test(component_count: 2)
+
+      written_chunks = []
+      stream_closed = false
+
+      # Simulate client disconnect on third write (after TEMPLATE and first component chunk)
+      allow(stream).to receive(:write) do |chunk|
+        if written_chunks.length == 2
+          stream_closed = true
+          raise IOError, "client disconnected"
+        end
+        written_chunks << chunk
+      end
+
+      # Make closed? return the stream_closed flag
+      allow(stream).to receive(:closed?) { stream_closed }
+
+      run_stream(controller) do |_parent|
+        # First write will be "TEMPLATE" (automatic)
+        sleep 0.05
+
+        # Enqueue chunks from both components
+        queues[0].enqueue("A1")  # Second write
+        sleep 0.05
+
+        queues[1].enqueue("B1")  # Third write - this should trigger disconnect
+        sleep 0.05
+
+        queues[0].enqueue("A2")  # Should not be written (producer stopped)
+        queues[1].enqueue("B2")  # Should not be written (producer stopped)
+        sleep 0.05
+
+        queues.each(&:close)
+      end
+
+      # Should have written TEMPLATE and first component chunk before disconnect
+      expect(written_chunks.length).to eq(2)
+      expect(written_chunks).to eq(["TEMPLATE", "A1"])
+    end
   end
 end