Add integration test for body duplication prevention

Addresses test coverage gap identified in code review. The new test:

1. Simulates a mid-stream connection error after partial chunks are sent
2. Verifies that StreamRequest properly retries with a fresh request
3. Confirms no duplicate chunks are yielded to the client

Test scenario:
- First attempt: sends "Chunk 1" then raises HTTPX::HTTPError
- Second attempt: successfully sends all 3 chunks
- Expected result: client receives exactly ["Chunk 1", "Chunk 2", "Chunk 3"]
- If HTTPx retries were enabled: would receive 4 chunks (duplication!)

This integration test validates the complete fix for #1895 by ensuring
that the combination of connection_without_retries and StreamRequest's
retry logic prevents body duplication.

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

Co-Authored-By: Claude <[email protected]>

Author: justin808

react_on_rails_pro/spec/react_on_rails_pro/request_spec.rb

@@ -204,9 +204,6 @@
       # Reset connections to ensure we're using a fresh connection
       described_class.reset_connection
 
-      # Create a spy to check if retries plugin is used
-      allow(HTTPX).to receive(:plugin).and_call_original
-
       # Trigger a streaming request
       mock_streaming_response(render_full_url, 200) do |yielder|
         yielder.call("Test chunk\n")
@@ -224,5 +221,56 @@
       connection_without_retries = described_class.send(:connection_without_retries)
       expect(connection_without_retries).to be_a(HTTPX::Session)
     end
+
+    it "prevents body duplication when streaming request is retried after mid-transmission error" do
+      # This integration test verifies the complete fix for https://github.com/shakacode/react_on_rails/issues/1895
+      # It ensures that when a streaming request fails mid-transmission and is retried,
+      # the client doesn't receive duplicate chunks.
+
+      described_class.reset_connection
+
+      # Track how many times the request is made to verify retry behavior
+      request_attempt = 0
+      original_chunks = ["Chunk 1", "Chunk 2", "Chunk 3"]
+
+      # Mock a streaming response that fails on first attempt, succeeds on second
+      connection = described_class.send(:connection_without_retries)
+      allow(connection).to receive(:post).and_wrap_original do |original_method, *args, **kwargs|
+        if kwargs[:stream]
+          request_attempt += 1
+
+          # Set up mock based on attempt number
+          if request_attempt == 1
+            # First attempt: simulate mid-transmission failure (HTTPError during streaming)
+            # This simulates a connection error after partial data is sent
+            mock_streaming_response(render_full_url, 200) do |yielder|
+              yielder.call("#{original_chunks[0]}\n")
+              # Simulate connection error mid-stream
+              raise HTTPX::HTTPError.new("Connection error", nil)
+            end
+          else
+            # Second attempt: complete all chunks successfully
+            mock_streaming_response(render_full_url, 200) do |yielder|
+              original_chunks.each { |chunk| yielder.call("#{chunk}\n") }
+            end
+          end
+        end
+
+        original_method.call(*args, **kwargs)
+      end
+
+      stream = described_class.render_code_as_stream("/render", "console.log('test');", is_rsc_payload: false)
+      received_chunks = []
+
+      # StreamRequest should handle the retry and yield all chunks exactly once
+      stream.each_chunk { |chunk| received_chunks << chunk }
+
+      # Verify no duplication: should have exactly 3 chunks, not 4 (1 from failed + 3 from retry)
+      expect(received_chunks).to eq(original_chunks)
+      expect(received_chunks.size).to eq(3)
+
+      # Verify retry actually happened
+      expect(request_attempt).to eq(2)
+    end
   end
 end