Add integration tests for incremental rendering with bidirectional streaming

Add comprehensive integration tests to verify incremental rendering functionality:

- Test bundle upload to node renderer using fixture bundles
- Test simple non-streaming render request using ReactOnRails.dummy
- Test incremental rendering with stream values
- Test bidirectional streaming to ensure chunks are received concurrently

Tests use simple fixture bundles from packages/node-renderer/tests/fixtures/
to avoid complexity and focus on testing the HTTP/streaming protocol between
Ruby and the Node renderer.

Key testing approach:
- Mock populate_form_with_bundle_and_assets to use real fixture bundles
- Mock AsyncPropsEmitter to generate proper update chunks
- Use Async::Condition for bidirectional streaming verification
- Timeout wrapper prevents deadlock if streaming isn't truly bidirectional

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

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

Author: AbanoubGhadban

react_on_rails_pro/lib/react_on_rails_pro/async_props_emitter.rb

@@ -13,7 +13,7 @@ def initialize(bundle_timestamp, request_stream)
     # Sends an update chunk to the node renderer to resolve an async prop
     def call(prop_name, prop_value)
       update_chunk = generate_update_chunk(prop_name, prop_value)
-      @request_stream.write("#{update_chunk.to_json}\n")
+      @request_stream << "#{update_chunk.to_json}\n"
     rescue StandardError => e
       Rails.logger.error do
         "[ReactOnRailsPro] Failed to send async prop '#{prop_name}': #{e.message}"

react_on_rails_pro/lib/react_on_rails_pro/request.rb

@@ -65,9 +65,9 @@ def render_code_with_incremental_updates(path, js_code, async_props_block:, is_r
           # Create emitter and use it to generate initial request data
           emitter = ReactOnRailsPro::AsyncPropsEmitter.new(bundle_timestamp, request)
           initial_data = build_initial_incremental_request(js_code, emitter)
-          request.write("#{initial_data.to_json}\n")
 
           response = incremental_connection.request(request, stream: true)
+          request << "#{initial_data.to_json}\n"
 
           # Execute async props block in background using barrier
           barrier.async do

react_on_rails_pro/spec/dummy/spec/requests/incremental_rendering_integration_spec.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+# Integration tests for incremental rendering with bidirectional streaming
+#
+# IMPORTANT: These tests require a running node-renderer server.
+# Before running these tests:
+#   1. cd packages/node-renderer
+#   2. yarn test:setup  # or equivalent command to start the test server
+#   3. Keep the server running in a separate terminal
+#
+# Then run these tests:
+#   bundle exec rspec spec/requests/incremental_rendering_integration_spec.rb
+#
+describe "Incremental Rendering Integration", :integration do
+  let(:server_bundle_hash) { "test_incremental_bundle" }
+  # Fixture bundle paths (real files on disk)
+  let(:fixture_bundle_path) do
+    File.expand_path(
+      "../../../../packages/node-renderer/tests/fixtures/bundle-incremental.js",
+      __dir__
+    )
+  end
+  let(:fixture_rsc_bundle_path) do
+    File.expand_path(
+      "../../../../packages/node-renderer/tests/fixtures/secondary-bundle-incremental.js",
+      __dir__
+    )
+  end
+  let(:rsc_bundle_hash) { "test_incremental_rsc_bundle" }
+
+  before do
+    allow(ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool).to receive_messages(
+      server_bundle_hash: server_bundle_hash,
+      rsc_bundle_hash: rsc_bundle_hash,
+      renderer_bundle_file_name: "#{server_bundle_hash}.js",
+      rsc_renderer_bundle_file_name: "#{rsc_bundle_hash}.js"
+    )
+
+    # Enable RSC support for these tests
+    allow(ReactOnRailsPro.configuration).to receive(:enable_rsc_support).and_return(true)
+
+    # Mock populate_form_with_bundle_and_assets to use fixture bundles directly
+    # rubocop:disable Lint/UnusedBlockArgument
+    allow(ReactOnRailsPro::Request).to receive(:populate_form_with_bundle_and_assets) do |form, check_bundle:|
+      # rubocop:enable Lint/UnusedBlockArgument
+      form["bundle_#{server_bundle_hash}"] = {
+        body: Pathname.new(fixture_bundle_path),
+        content_type: "text/javascript",
+        filename: "#{server_bundle_hash}.js"
+      }
+
+      form["bundle_#{rsc_bundle_hash}"] = {
+        body: Pathname.new(fixture_rsc_bundle_path),
+        content_type: "text/javascript",
+        filename: "#{rsc_bundle_hash}.js"
+      }
+    end
+
+    # Mock AsyncPropsEmitter chunk generation methods to work with fixture bundles
+    # Only mock the chunk generation, not the actual call/streaming logic
+    # rubocop:disable RSpec/AnyInstance
+    allow_any_instance_of(ReactOnRailsPro::AsyncPropsEmitter)
+      .to receive(:generate_update_chunk) do |emitter, _prop_name, value|
+        bundle_timestamp = emitter.instance_variable_get(:@bundle_timestamp)
+        {
+          bundleTimestamp: bundle_timestamp,
+          # Add newline to the value so the fixture bundle writes it with newline
+          updateChunk: "ReactOnRails.addStreamValue(#{value.to_json} + '\\n')"
+        }
+      end
+
+    allow_any_instance_of(ReactOnRailsPro::AsyncPropsEmitter).to receive(:end_stream_chunk).and_call_original
+    allow_any_instance_of(ReactOnRailsPro::AsyncPropsEmitter).to receive(:generate_end_stream_js).and_return(
+      "ReactOnRails.endStream()"
+    )
+    # rubocop:enable RSpec/AnyInstance
+
+    # Reset any existing connections to ensure clean state
+    ReactOnRailsPro::Request.reset_connection
+  end
+
+  after do
+    ReactOnRailsPro::Request.reset_connection
+  end
+
+  describe "upload_assets" do
+    it "successfully uploads fixture bundles to the node renderer" do
+      expect do
+        ReactOnRailsPro::Request.upload_assets
+      end.not_to raise_error
+    end
+  end
+
+  describe "render_code" do
+    it "renders simple non-streaming request using ReactOnRails.dummy" do
+      # Upload bundles first
+      ReactOnRailsPro::Request.upload_assets
+
+      # Construct the render path: /bundles/:bundleTimestamp/render/:renderRequestDigest
+      js_code = "ReactOnRails.dummy"
+      request_digest = Digest::MD5.hexdigest(js_code)
+      render_path = "/bundles/#{server_bundle_hash}/render/#{request_digest}"
+
+      # Render using the fixture bundle
+      response = ReactOnRailsPro::Request.render_code(render_path, js_code, false)
+
+      expect(response.status).to eq(200)
+      expect(response.body.to_s).to include("Dummy Object")
+    end
+  end
+
+  describe "render_code_with_incremental_updates" do
+    it "sends stream values and receives them in the response" do
+      # Upload bundles first
+      ReactOnRailsPro::Request.upload_assets
+
+      # Construct the incremental render path
+      js_code = "ReactOnRails.getStreamValues()"
+      request_digest = Digest::MD5.hexdigest(js_code)
+      render_path = "/bundles/#{server_bundle_hash}/incremental-render/#{request_digest}"
+
+      # Perform incremental rendering with stream updates
+      stream = ReactOnRailsPro::Request.render_code_with_incremental_updates(
+        render_path,
+        js_code,
+        async_props_block: proc { |emitter|
+          emitter.call("prop1", "value1")
+          emitter.call("prop2", "value2")
+          emitter.call("prop3", "value3")
+        },
+        is_rsc_payload: false
+      )
+
+      # Collect all chunks from the stream
+      chunks = []
+      stream.each_chunk do |chunk|
+        chunks << chunk
+      end
+
+      # Verify we received all the values
+      response_text = chunks.join
+      expect(response_text).to include("value1")
+      expect(response_text).to include("value2")
+      expect(response_text).to include("value3")
+    end
+
+    it "streams bidirectionally - each_chunk receives chunks while async_props_block is still running" do
+      # Upload bundles first
+      ReactOnRailsPro::Request.upload_assets
+
+      # Construct the incremental render path
+      js_code = "ReactOnRails.getStreamValues()"
+      request_digest = Digest::MD5.hexdigest(js_code)
+      render_path = "/bundles/#{server_bundle_hash}/incremental-render/#{request_digest}"
+
+      # Single condition to signal when each chunk is received
+      chunk_received = Async::Condition.new
+
+      # Wrap the test in a timeout to prevent hanging forever on deadlock
+      Timeout.timeout(10) do
+        # Perform incremental rendering with bidirectional verification
+        stream = ReactOnRailsPro::Request.render_code_with_incremental_updates(
+          render_path,
+          js_code,
+          async_props_block: proc { |emitter|
+            # Send first value and wait for confirmation
+            emitter.call("prop1", "value1")
+            chunk_received.wait
+
+            # Send second value and wait for confirmation
+            emitter.call("prop2", "value2")
+            chunk_received.wait
+
+            # Send third value and wait for confirmation
+            emitter.call("prop3", "value3")
+            chunk_received.wait
+
+            # If we reach here, all chunks were received while async_block was running
+          },
+          is_rsc_payload: false
+        )
+
+        # Collect chunks and signal after each one
+        chunks = []
+        stream.each_chunk do |chunk|
+          chunks << chunk
+          chunk_received.signal
+        end
+
+        # Verify all values were received
+        response_text = chunks.join
+        expect(response_text).to include("value1")
+        expect(response_text).to include("value2")
+        expect(response_text).to include("value3")
+
+        # If this test completes without deadlock, it proves bidirectional streaming:
+        # - async_props_block sent chunks and waited for confirmation
+        # - each_chunk received chunks and signaled back while async_props_block was still running
+        # - This would deadlock if chunks weren't received concurrently
+      end
+    end
+  end
+end