react_on_rails 16.2.0.beta.3 → 16.2.0.beta.8

data/react_on_rails_pro/spec/dummy/yarn.lock

@@ -1228,10 +1228,6 @@
   dependencies:
     "@sentry/types" "7.120.0"
 
-"@shakacode-tools/react-on-rails-pro-node-renderer@link:.yalc/@shakacode-tools/react-on-rails-pro-node-renderer":
-  version "0.0.0"
-  uid ""
-
 "@shakacode/use-ssr-computation.macro@^1.2.4":
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/@shakacode/use-ssr-computation.macro/-/use-ssr-computation.macro-1.2.4.tgz#b247d683e3133126dbdb42060c26e1c34a8b625d"
@@ -5461,6 +5457,10 @@ react-is@^16.12.0, react-is@^16.13.1, react-is@^16.7.0:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
 
+"react-on-rails-pro-node-renderer@link:.yalc/react-on-rails-pro-node-renderer":
+  version "0.0.0"
+  uid ""
+
 "react-on-rails-pro@link:.yalc/react-on-rails-pro":
   version "0.0.0"
   uid ""

data/react_on_rails_pro/spec/execjs-compatible-dummy/config/environments/production.rb

@@ -55,7 +55,7 @@ Rails.application.configure do
 
   # Log to STDOUT by default
   config.logger = ActiveSupport::Logger.new($stdout)
-                                       .tap  { |logger| logger.formatter = ::Logger::Formatter.new }
+                                       .tap  { |logger| logger.formatter = Logger::Formatter.new }
                                        .then { |logger| ActiveSupport::TaggedLogging.new(logger) }
 
   # Prepend all log lines with the following tags.

data/react_on_rails_pro/spec/execjs-compatible-dummy/config/initializers/react_on_rails.rb

@@ -1,58 +1,31 @@
 # frozen_string_literal: true
 
-# See https://github.com/shakacode/react_on_rails/blob/master/docs/guides/configuration.md
-# for many more options.
+# ⚠️ TEST CONFIGURATION - Do not copy directly for production apps
+# This is the ExecJS-compatible dummy app for testing legacy webpacker compatibility.
+# See docs/api-reference/configuration.md for production configuration guidance.
 
 ReactOnRails.configure do |config|
-  # This configures the script to run to build the production assets by webpack. Set this to nil
-  # if you don't want react_on_rails building this file for you.
-  # If nil, then the standard shakacode/webpacker assets:precompile will run
-  # config.build_production_command = nil
-
-  ################################################################################
   ################################################################################
-  # TEST CONFIGURATION OPTIONS
-  # Below options are used with the use of this test helper:
-  # ReactOnRails::TestHelper.configure_rspec_to_compile_assets(config)
+  # Essential Configuration
   ################################################################################
+  # Configure server bundle for server-side rendering
+  config.server_bundle_js_file = "server-bundle.js"
 
-  # If you are using this in your spec_helper.rb (or rails_helper.rb):
-  #
-  # ReactOnRails::TestHelper.configure_rspec_to_compile_assets(config)
-  #
-  # with rspec then this controls what yarn command is run
-  # to automatically refresh your webpack assets on every test run.
-  #
-  # Alternately, you can remove the `ReactOnRails::TestHelper.configure_rspec_to_compile_assets`
-  # and set the config/webpacker.yml option for test to true.
+  # Test configuration
   config.build_test_command = "RAILS_ENV=test bin/webpacker"
 
   ################################################################################
+  # File System Based Component Registry (Optional - Disabled for this test)
   ################################################################################
-  # SERVER RENDERING OPTIONS
-  ################################################################################
-  # This is the file used for server rendering of React when using `(prerender: true)`
-  # If you are never using server rendering, you should set this to "".
-  # Note, there is only one server bundle, unlike JavaScript where you want to minimize the size
-  # of the JS sent to the client. For the server rendering, React on Rails creates a pool of
-  # JavaScript execution instances which should handle any component requested.
-  #
-  # While you may configure this to be the same as your client bundle file, this file is typically
-  # different. You should have ONE server bundle which can create all of your server rendered
-  # React components.
-  #
-  config.server_bundle_js_file = "server-bundle.js"
+  # Uncomment to enable automatic component registration:
+  # config.components_subdirectory = "ror_components"
+  # config.auto_load_bundle = true
+  config.auto_load_bundle = false
 
   ################################################################################
+  # Advanced Configuration
   ################################################################################
-  # FILE SYSTEM BASED COMPONENT REGISTRY
-  ################################################################################
-  # `components_subdirectory`  is the name of the matching directories that contain automatically registered components
-  # for use in the Rails views. The default is nil, you can enable the feature by updating it in the next line.
-  # config.components_subdirectory = "ror_components"
-  #
-  # For automated component registry, `render_component` view helper method tries to load bundle for component from
-  # generated directory. default is false, you can pass option at the time of individual usage or update the default
-  # in the following line
-  config.auto_load_bundle = false
+  # Most options have sensible defaults. For advanced configuration including
+  # component loading strategies, server bundle security, and more, see:
+  # https://github.com/shakacode/react_on_rails/blob/master/docs/api-reference/configuration.md
 end

data/react_on_rails_pro/spec/react_on_rails_pro/assets_precompile_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "./spec_helper"
+require_relative "spec_helper"
 require_relative "../../lib/react_on_rails_pro/assets_precompile"
 
 describe ReactOnRailsPro::AssetsPrecompile do
@@ -46,8 +46,6 @@ describe ReactOnRailsPro::AssetsPrecompile do
 
       ror_pro_config = instance_double(ReactOnRailsPro::Configuration)
 
-      allow(ror_pro_config).to receive(:dependency_globs).and_return([expected_parameters.last])
-
       adapter = Module.new do
         def self.cache_keys
           %w[a b]
@@ -58,7 +56,8 @@ describe ReactOnRailsPro::AssetsPrecompile do
         end
       end
 
-      allow(ror_pro_config).to receive(:remote_bundle_cache_adapter).and_return(adapter)
+      allow(ror_pro_config).to receive_messages(dependency_globs: [expected_parameters.last],
+                                                remote_bundle_cache_adapter: adapter)
 
       stub_const("ReactOnRailsPro::VERSION", "2.2.0")
 
@@ -136,11 +135,10 @@ describe ReactOnRailsPro::AssetsPrecompile do
       it "calls build_bundles & cache_bundles if cached bundles can't be fetched" do
         instance = described_class.instance
 
-        allow(instance).to receive(:fetch_and_unzip_cached_bundles).and_return(false)
         expect(instance).to receive(:fetch_and_unzip_cached_bundles).once
-        allow(instance).to receive(:build_bundles).and_return(nil)
         expect(instance).to receive(:build_bundles).once
-        allow(instance).to receive(:cache_bundles).and_return(nil)
+        allow(instance).to receive_messages(fetch_and_unzip_cached_bundles: false, build_bundles: nil,
+                                            cache_bundles: nil)
         expect(instance).to receive(:cache_bundles).once
 
         instance.build_or_fetch_bundles
@@ -179,9 +177,9 @@ describe ReactOnRailsPro::AssetsPrecompile do
       unique_variable = { unique_key: "a unique value" }
 
       instance = described_class.instance
-      allow(instance).to receive(:remote_bundle_cache_adapter).and_return(adapter_double)
-      allow(instance).to receive(:zipped_bundles_filename).and_return(unique_variable)
-      allow(instance).to receive(:zipped_bundles_filepath).and_return("zipped_bundles_filepath")
+      allow(instance).to receive_messages(remote_bundle_cache_adapter: adapter_double,
+                                          zipped_bundles_filename: unique_variable,
+                                          zipped_bundles_filepath: "zipped_bundles_filepath")
 
       allow(File).to receive(:binwrite).and_return(true)
       expect(File).to receive(:binwrite).once
@@ -197,8 +195,7 @@ describe ReactOnRailsPro::AssetsPrecompile do
       allow(File).to receive(:exist?).and_return(false)
 
       instance = described_class.instance
-      allow(instance).to receive(:fetch_bundles).and_return(false)
-      allow(instance).to receive(:zipped_bundles_filepath).and_return("a")
+      allow(instance).to receive_messages(fetch_bundles: false, zipped_bundles_filepath: "a")
 
       expect(instance.fetch_and_unzip_cached_bundles).to be(false)
     end
@@ -256,10 +253,10 @@ describe ReactOnRailsPro::AssetsPrecompile do
       zipped_bundles_filepath = Pathname.new(Dir.tmpdir).join("foobar")
 
       instance = described_class.instance
-      allow(instance).to receive(:remote_bundle_cache_adapter).and_return(adapter_double)
-      allow(instance).to receive(:zipped_bundles_filename).and_return("zipped_bundles_filename")
-      allow(instance).to receive(:zipped_bundles_filepath).and_return(zipped_bundles_filepath)
-      allow(instance).to receive(:remove_extra_files_cache_dir).and_return(nil)
+      allow(instance).to receive_messages(remote_bundle_cache_adapter: adapter_double,
+                                          zipped_bundles_filename: "zipped_bundles_filename",
+                                          zipped_bundles_filepath: zipped_bundles_filepath,
+                                          remove_extra_files_cache_dir: nil)
 
       expect(instance.cache_bundles).to be_truthy
 
@@ -289,8 +286,8 @@ describe ReactOnRailsPro::AssetsPrecompile do
 
       instance = described_class.instance
 
-      allow(instance).to receive(:remote_bundle_cache_adapter).and_return(adapter)
-      allow(instance).to receive(:extra_files_path).and_return(Pathname.new(Dir.pwd).join("extra_files_cache_dir"))
+      allow(instance).to receive_messages(remote_bundle_cache_adapter: adapter,
+                                          extra_files_path: Pathname.new(Dir.pwd).join("extra_files_cache_dir"))
       copied_gemfile_path = Pathname.new(Dir.pwd).join("extra_files_cache_dir", "Gemfile")
       copied_assets_precompile_path = Pathname.new(Dir.pwd).join("extra_files_cache_dir",
                                                                  "lib---react_on_rails_pro---assets_precompile.rb")

data/react_on_rails_pro/spec/react_on_rails_pro/cache_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "./spec_helper"
+require_relative "spec_helper"
 
 class TestingCache
   def call; end

data/react_on_rails_pro/spec/react_on_rails_pro/configuration_spec.rb

@@ -2,7 +2,7 @@
 
 require_relative "spec_helper"
 
-module ReactOnRailsPro
+module ReactOnRailsPro # rubocop:disable Metrics/ModuleLength
   RSpec.describe Configuration do
     after do
       ReactOnRailsPro.instance_variable_set(:@configuration, nil)
@@ -205,7 +205,8 @@ module ReactOnRailsPro
 
         expect(ReactOnRailsPro.configuration.rsc_bundle_js_file).to eq("rsc-bundle.js")
         expect(ReactOnRailsPro.configuration.react_client_manifest_file).to eq("react-client-manifest.json")
-        expect(ReactOnRailsPro.configuration.react_server_client_manifest_file).to eq("react-server-client-manifest.json")
+        expect(ReactOnRailsPro.configuration.react_server_client_manifest_file)
+          .to eq("react-server-client-manifest.json")
       end
 
       it "allows setting rsc_bundle_js_file" do
@@ -229,7 +230,8 @@ module ReactOnRailsPro
           config.react_server_client_manifest_file = "custom-server-client-manifest.json"
         end
 
-        expect(ReactOnRailsPro.configuration.react_server_client_manifest_file).to eq("custom-server-client-manifest.json")
+        expect(ReactOnRailsPro.configuration.react_server_client_manifest_file)
+          .to eq("custom-server-client-manifest.json")
       end
 
       it "allows nil values for RSC configuration options" do

data/react_on_rails_pro/spec/react_on_rails_pro/license_validator_spec.rb

@@ -75,26 +75,30 @@ RSpec.describe ReactOnRailsPro::LicenseValidator do
         ENV["REACT_ON_RAILS_PRO_LICENSE"] = expired_token
       end
 
-      context "in development/test environment" do
+      context "when in development/test environment" do
         before do
           allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("development"))
         end
 
         it "raises error immediately" do
-          expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /License has expired/)
+          expect do
+            described_class.validated_license_data!
+          end.to raise_error(ReactOnRailsPro::Error, /License has expired/)
         end
 
         it "includes FREE license information in error message" do
-          expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+          expect do
+            described_class.validated_license_data!
+          end.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
         end
       end
 
-      context "in production environment" do
+      context "when in production environment" do
         before do
           allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("production"))
         end
 
-        context "within grace period (expired < 1 month ago)" do
+        context "with grace period (expired < 1 month ago)" do
           let(:expired_within_grace) do
             {
               sub: "test@example.com",
@@ -113,7 +117,8 @@ RSpec.describe ReactOnRailsPro::LicenseValidator do
           end
 
           it "logs warning with grace period remaining" do
-            expect(mock_logger).to receive(:error).with(/WARNING:.*License has expired.*Grace period:.*day\(s\) remaining/)
+            expect(mock_logger).to receive(:error)
+              .with(/WARNING:.*License has expired.*Grace period:.*day\(s\) remaining/)
             described_class.validated_license_data!
           end
 
@@ -123,7 +128,7 @@ RSpec.describe ReactOnRailsPro::LicenseValidator do
           end
         end
 
-        context "outside grace period (expired > 1 month ago)" do
+        context "when outside grace period (expired > 1 month ago)" do
           let(:expired_outside_grace) do
             {
               sub: "test@example.com",
@@ -138,11 +143,15 @@ RSpec.describe ReactOnRailsPro::LicenseValidator do
           end
 
           it "raises error" do
-            expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /License has expired/)
+            expect do
+              described_class.validated_license_data!
+            end.to raise_error(ReactOnRailsPro::Error, /License has expired/)
           end
 
           it "includes FREE license information in error message" do
-            expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+            expect do
+              described_class.validated_license_data!
+            end.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
           end
         end
       end
@@ -168,7 +177,9 @@ RSpec.describe ReactOnRailsPro::LicenseValidator do
       end
 
       it "includes FREE license information in error message" do
-        expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+        expect do
+          described_class.validated_license_data!
+        end.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
       end
     end
 
@@ -180,11 +191,15 @@ RSpec.describe ReactOnRailsPro::LicenseValidator do
       end
 
       it "raises error" do
-        expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /Invalid license signature/)
+        expect do
+          described_class.validated_license_data!
+        end.to raise_error(ReactOnRailsPro::Error, /Invalid license signature/)
       end
 
       it "includes FREE license information in error message" do
-        expect { described_class.validated_license_data! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+        expect do
+          described_class.validated_license_data!
+        end.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
       end
     end
 

data/react_on_rails_pro/spec/react_on_rails_pro/request_spec.rb

@@ -194,32 +194,5 @@ describe ReactOnRailsPro::Request do
         expect(mocked_block).not_to have_received(:call)
       end
     end
-
-    it "does not use HTTPx retries plugin for streaming requests to prevent body duplication" do
-      # This test verifies the fix for https://github.com/shakacode/react_on_rails/issues/1895
-      # When streaming requests encounter connection errors mid-transmission, HTTPx retries
-      # would cause body duplication because partial chunks are already sent to the client.
-      # The StreamRequest class handles retries properly by starting fresh requests.
-
-      # Reset connections to ensure we're using a fresh connection
-      described_class.reset_connection
-
-      # Trigger a streaming request
-      mock_streaming_response(render_full_url, 200) do |yielder|
-        yielder.call("Test chunk\n")
-      end
-
-      stream = described_class.render_code_as_stream("/render", "console.log('test');", is_rsc_payload: false)
-      chunks = []
-      stream.each_chunk { |chunk| chunks << chunk }
-
-      # Verify that the streaming request completed successfully
-      expect(chunks).to eq(["Test chunk"])
-
-      # Verify that the connection_without_retries was created
-      # by checking that a connection was created with retries disabled
-      connection_without_retries = described_class.send(:connection_without_retries)
-      expect(connection_without_retries).to be_a(HTTPX::Session)
-    end
   end
 end

data/react_on_rails_pro/spec/react_on_rails_pro/spec_helper.rb

@@ -15,7 +15,7 @@ require "rails"
 require "rails/test_help"
 Rails.backtrace_cleaner.remove_silencers!
 
-require_relative "./simplecov_helper"
+require_relative "simplecov_helper"
 # prevent Test::Unit's AutoRunner from executing during RSpec's rake task
 Test::Unit.run = true if defined?(Test::Unit) && Test::Unit.respond_to?(:run=)
 

data/react_on_rails_pro/spec/react_on_rails_pro/stream_decorator_spec.rb

@@ -62,4 +62,93 @@ RSpec.describe ReactOnRailsPro::StreamDecorator do
       expect(chunks.last).to end_with("-end")
     end
   end
+
+  describe "#rescue" do
+    it "catches the error happens inside the component" do
+      allow(mock_component).to receive(:each_chunk).and_raise(StandardError.new("Fake Error"))
+      mocked_block = mock_block
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(mocked_block).to have_received(:call) do |error|
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq("Fake Error")
+      end
+      expect(chunks).to eq([])
+    end
+
+    it "catches the error happens inside subsequent component calls" do
+      allow(mock_component).to receive(:each_chunk).and_yield("Chunk1").and_raise(ArgumentError.new("Fake Error"))
+      mocked_block = mock_block
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(mocked_block).to have_received(:call) do |error|
+        expect(chunks).to eq(["Chunk1"])
+        expect(error).to be_a(ArgumentError)
+        expect(error.message).to eq("Fake Error")
+      end
+      expect(chunks).to eq(["Chunk1"])
+    end
+
+    it "can yield values to the stream" do
+      allow(mock_component).to receive(:each_chunk).and_yield("Chunk1").and_raise(ArgumentError.new("Fake Error"))
+      mocked_block = mock_block
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(mocked_block).to have_received(:call) do |error, &inner_block|
+        expect(chunks).to eq(["Chunk1"])
+        expect(error).to be_a(ArgumentError)
+        expect(error.message).to eq("Fake Error")
+
+        inner_block.call "Chunk from rescue block"
+        inner_block.call "Chunk2 from rescue block"
+      end
+      expect(chunks).to eq(["Chunk1", "Chunk from rescue block", "Chunk2 from rescue block"])
+    end
+
+    it "can convert the error into another error" do
+      allow(mock_component).to receive(:each_chunk).and_raise(StandardError.new("Fake Error"))
+      mocked_block = mock_block do |error|
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq("Fake Error")
+        raise ArgumentError, "Another Error"
+      end
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.to raise_error(ArgumentError, "Another Error")
+      expect(chunks).to eq([])
+    end
+
+    it "chains multiple rescue blocks" do
+      allow(mock_component).to receive(:each_chunk).and_yield("Chunk1").and_raise(StandardError.new("Fake Error"))
+      fist_rescue_block = mock_block do |error, &block|
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq("Fake Error")
+        block.call "Chunk from first rescue block"
+        raise ArgumentError, "Another Error"
+      end
+
+      second_rescue_block = mock_block do |error, &block|
+        expect(error).to be_a(ArgumentError)
+        expect(error.message).to eq("Another Error")
+        block.call "Chunk from second rescue block"
+      end
+
+      stream_decorator.rescue(&fist_rescue_block.block)
+      stream_decorator.rescue(&second_rescue_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(chunks).to eq(["Chunk1", "Chunk from first rescue block", "Chunk from second rescue block"])
+    end
+  end
 end

data/react_on_rails_pro/spec/react_on_rails_pro/stream_spec.rb

@@ -1,7 +1,35 @@
 # frozen_string_literal: true
 
+require "async"
+require "async/queue"
 require_relative "spec_helper"
 
+class StreamController
+  include ReactOnRailsPro::Stream
+
+  attr_reader :response
+
+  def initialize(component_queues:, initial_response: "TEMPLATE")
+    @component_queues = component_queues
+    @initial_response = initial_response
+  end
+
+  def render_to_string(**_opts)
+    @rorp_rendering_fibers = @component_queues.map do |queue|
+      Fiber.new do
+        loop do
+          chunk = queue.dequeue
+          break if chunk.nil?
+
+          Fiber.yield chunk
+        end
+      end
+    end
+
+    @initial_response
+  end
+end
+
 RSpec.describe "Streaming API" do
   let(:origin) { "http://api.example.com" }
   let(:path) { "/stream" }
@@ -342,4 +370,120 @@ RSpec.describe "Streaming API" do
       expect(mocked_block).to have_received(:call).with("First chunk")
     end
   end
+
+  describe "Component streaming concurrency" do
+    def run_stream(controller, template: "ignored")
+      Sync do |parent|
+        parent.async { controller.stream_view_containing_react_components(template: template) }
+        yield(parent)
+      end
+    end
+
+    def setup_stream_test(component_count: 2)
+      component_queues = Array.new(component_count) { Async::Queue.new }
+      controller = StreamController.new(component_queues: component_queues)
+
+      mocked_response = instance_double(ActionController::Live::Response)
+      mocked_stream = instance_double(ActionController::Live::Buffer)
+      allow(mocked_response).to receive(:stream).and_return(mocked_stream)
+      allow(mocked_stream).to receive(:write)
+      allow(mocked_stream).to receive(:close)
+      allow(controller).to receive(:response).and_return(mocked_response)
+
+      [component_queues, controller, mocked_stream]
+    end
+
+    it "streams components concurrently" do
+      queues, controller, stream = setup_stream_test
+
+      run_stream(controller) do |_parent|
+        queues[1].enqueue("B1")
+        sleep 0.05
+        expect(stream).to have_received(:write).with("B1")
+
+        queues[0].enqueue("A1")
+        sleep 0.05
+        expect(stream).to have_received(:write).with("A1")
+
+        queues[1].enqueue("B2")
+        queues[1].close
+        sleep 0.05
+
+        queues[0].enqueue("A2")
+        queues[0].close
+        sleep 0.1
+      end
+    end
+
+    it "maintains per-component ordering" do
+      queues, controller, stream = setup_stream_test
+
+      run_stream(controller) do |_parent|
+        queues[0].enqueue("X1")
+        queues[0].enqueue("X2")
+        queues[0].enqueue("X3")
+        queues[0].close
+
+        queues[1].enqueue("Y1")
+        queues[1].enqueue("Y2")
+        queues[1].close
+
+        sleep 0.2
+      end
+
+      # Verify all chunks were written
+      expect(stream).to have_received(:write).with("X1")
+      expect(stream).to have_received(:write).with("X2")
+      expect(stream).to have_received(:write).with("X3")
+      expect(stream).to have_received(:write).with("Y1")
+      expect(stream).to have_received(:write).with("Y2")
+    end
+
+    it "handles empty component list" do
+      _queues, controller, stream = setup_stream_test(component_count: 0)
+
+      run_stream(controller) do |_parent|
+        sleep 0.1
+      end
+
+      expect(stream).to have_received(:write).with("TEMPLATE")
+      expect(stream).to have_received(:close)
+    end
+
+    it "handles single component" do
+      queues, controller, stream = setup_stream_test(component_count: 1)
+
+      run_stream(controller) do |_parent|
+        queues[0].enqueue("Single1")
+        queues[0].enqueue("Single2")
+        queues[0].close
+
+        sleep 0.1
+      end
+
+      expect(stream).to have_received(:write).with("Single1")
+      expect(stream).to have_received(:write).with("Single2")
+    end
+
+    it "applies backpressure with slow writer" do
+      queues, controller, stream = setup_stream_test(component_count: 1)
+
+      write_timestamps = []
+      allow(stream).to receive(:write) do |_data|
+        write_timestamps << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        sleep 0.05
+      end
+
+      run_stream(controller) do |_parent|
+        5.times { |i| queues[0].enqueue("Chunk#{i}") }
+        queues[0].close
+
+        sleep 1
+      end
+
+      expect(write_timestamps.length).to be >= 2
+      gaps = write_timestamps.each_cons(2).map { |a, b| b - a }
+      expect(gaps.all? { |gap| gap >= 0.04 }).to be true
+    end
+  end
 end

data/react_on_rails_pro/spec/react_on_rails_pro/support/caching.rb

@@ -4,7 +4,7 @@ RSpec.configure do |config|
   config.before(:each, :caching) do
     cache_store = ActiveSupport::Cache::MemoryStore.new
     allow(controller).to receive(:cache_store).and_return(cache_store) if defined?(controller) && controller
-    allow(::Rails).to receive(:cache).and_return(cache_store)
+    allow(Rails).to receive(:cache).and_return(cache_store)
     ReactOnRailsPro::Cache.instance_variable_set(:@serializer_checksum, nil)
     Rails.cache.clear
   end

data/react_on_rails_pro/spec/react_on_rails_pro/support/mock_block_helper.rb

@@ -9,9 +9,11 @@ module MockBlockHelper
   # mocked_block = mock_block
   # testing_method_taking_block(&mocked_block.block)
   # expect(mocked_block).to have_received(:call).with(1, 2, 3)
-  def mock_block(return_value: nil)
+  def mock_block(&block)
     double("BlockMock").tap do |mock| # rubocop:disable RSpec/VerifiedDoubles
-      allow(mock).to receive(:call) { return_value }
+      allow(mock).to receive(:call) do |*args, &inner_block|
+        block&.call(*args, &inner_block)
+      end
       def mock.block
         method(:call).to_proc
       end

data/sig/react_on_rails/controller.rbs

@@ -5,7 +5,7 @@ module ReactOnRails
 
     def redux_store: (
       String store_name,
-      ?props: untyped,
+      ?props: Hash[Symbol, untyped] | String,
       ?immediate_hydration: bool
     ) -> void