Wait to open browser until the app route is ready

Author: justin808

react_on_rails/lib/react_on_rails/dev/server_manager.rb

@@ -2,6 +2,7 @@
 
 require "English"
 require "fileutils"
+require "net/http"
 require "open3"
 require "rainbow"
 require "erb"
@@ -868,14 +869,23 @@ def build_local_url(port, route)
           "http://localhost:#{port}/#{normalized_route}"
         end
 
+        def build_request_path(route)
+          normalized_route = route.to_s.strip
+          return "/" if normalized_route.empty? || normalized_route == "/"
+
+          normalized_route = normalized_route.sub(%r{\A/+}, "")
+          "/#{normalized_route}"
+        end
+
         def schedule_browser_open(port, route:, once:)
           return unless browser_auto_open_allowed?
           return if once && File.exist?(OPEN_BROWSER_ONCE_MARKER)
 
           url = build_local_url(port, route)
+          request_path = build_request_path(route)
           Thread.new do
             Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
-            next unless wait_for_server_on_port(port)
+            next unless wait_for_app_route(port, request_path)
             next unless open_browser(url)
 
             mark_browser_opened_once if once
@@ -897,6 +907,32 @@ def wait_for_server_on_port(port)
           end
         end
 
+        def wait_for_app_route(port, request_path)
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + OPEN_BROWSER_WAIT_TIMEOUT
+
+          loop do
+            return true if app_route_ready?(port, request_path)
+            return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+            sleep OPEN_BROWSER_POLL_INTERVAL
+          end
+        end
+
+        def app_route_ready?(port, request_path)
+          return false unless localhost_port_open?(port)
+
+          response = http_get_localhost(port, request_path)
+          response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+        end
+
+        def http_get_localhost(port, request_path)
+          Net::HTTP.start("127.0.0.1", port, open_timeout: 1, read_timeout: 1) do |http|
+            http.get(request_path)
+          end
+        rescue StandardError
+          nil
+        end
+
         def localhost_port_open?(port)
           %w[127.0.0.1 ::1].any? do |host|
             Socket.tcp(host, port, connect_timeout: 1) do |socket|

react_on_rails/spec/react_on_rails/dev/server_manager_spec.rb

@@ -256,6 +256,50 @@ def mock_system_calls
     end
   end
 
+  describe "browser auto-open readiness" do
+    it "normalizes routes to request paths" do
+      expect(described_class.send(:build_request_path, nil)).to eq("/")
+      expect(described_class.send(:build_request_path, "/")).to eq("/")
+      expect(described_class.send(:build_request_path, "hello_world")).to eq("/hello_world")
+      expect(described_class.send(:build_request_path, "/hello_server")).to eq("/hello_server")
+    end
+
+    it "treats a successful response as ready" do
+      response = Net::HTTPOK.new("1.1", "200", "OK")
+      allow(described_class).to receive(:localhost_port_open?).with(3000).and_return(true)
+      allow(described_class).to receive(:http_get_localhost).with(3000, "/").and_return(response)
+
+      expect(described_class.send(:app_route_ready?, 3000, "/")).to be true
+    end
+
+    it "treats a redirect response as ready" do
+      response = Net::HTTPFound.new("1.1", "302", "Found")
+      allow(described_class).to receive(:localhost_port_open?).with(3000).and_return(true)
+      allow(described_class).to receive(:http_get_localhost).with(3000, "/").and_return(response)
+
+      expect(described_class.send(:app_route_ready?, 3000, "/")).to be true
+    end
+
+    it "does not treat a server error response as ready" do
+      response = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      allow(described_class).to receive(:localhost_port_open?).with(3000).and_return(true)
+      allow(described_class).to receive(:http_get_localhost).with(3000, "/").and_return(response)
+
+      expect(described_class.send(:app_route_ready?, 3000, "/")).to be false
+    end
+
+    it "waits for the route to respond successfully before opening the browser" do
+      allow(described_class).to receive(:browser_auto_open_allowed?).and_return(true)
+      allow(File).to receive(:exist?).with(described_class::OPEN_BROWSER_ONCE_MARKER).and_return(false)
+      allow(Thread).to receive(:new).and_yield
+      allow(described_class).to receive(:wait_for_app_route).with(3000, "/").and_return(true)
+      expect(described_class).to receive(:open_browser).with("http://localhost:3000").and_return(true)
+      expect(described_class).to receive(:mark_browser_opened_once)
+
+      described_class.send(:schedule_browser_open, 3000, route: "/", once: true)
+    end
+  end
+
   describe ".kill_processes" do
     before do
       allow_any_instance_of(Kernel).to receive(:`).and_return("")