react_on_rails 16.2.0.beta.4 → 16.2.0.beta.8

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: react_on_rails
 version: !ruby/object:Gem::Version
-  version: 16.2.0.beta.4
+  version: 16.2.0.beta.8
 platform: ruby
 authors:
 - Justin Gordon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-13 00:00:00.000000000 Z
+date: 2025-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -756,7 +756,6 @@ files:
 - react_on_rails_pro/spec/dummy/client/app/ror-auto-load-components/SetTimeoutLoggingApp.server.jsx
 - react_on_rails_pro/spec/dummy/client/app/ror-auto-load-components/SimpleComponent.jsx
 - react_on_rails_pro/spec/dummy/client/app/ror-auto-load-components/StreamAsyncComponents.jsx
-- react_on_rails_pro/spec/dummy/client/app/ror-auto-load-components/TestingStreamableComponent.jsx
 - react_on_rails_pro/spec/dummy/client/app/routes/routes.jsx
 - react_on_rails_pro/spec/dummy/client/app/ssr-computations/userQuery.ssr-computation.ts
 - react_on_rails_pro/spec/dummy/client/app/store/composeInitialState.js

data/react_on_rails_pro/spec/dummy/client/app/ror-auto-load-components/TestingStreamableComponent.jsx

@@ -1,15 +0,0 @@
-'use client';
-
-import React from 'react';
-
-// Simple test component for streaming SSR tests
-function TestingStreamableComponent({ helloWorldData }) {
-  return (
-    <div>
-      <div>Chunk 1: Stream React Server Components</div>
-      <div>Hello, {helloWorldData.name}!</div>
-    </div>
-  );
-}
-
-export default TestingStreamableComponent;