ruact 0.0.11 → 0.0.12

data/spec/ruact/query_spec.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-# Story 9.4 — unit spec for the Ruact::Query base class. Deliberately NO Rails
-# boot (AC3): a query subclass is exercised with a plain double standing in for
-# the dispatch context, proving `CatalogQuery.new(fake_context).categories` is
-# unit-testable in isolation.
-require "spec_helper"
-
-module Ruact
-  RSpec.describe Query, :story_9_4 do
-    let(:fake_user) { { "id" => 42 } }
-    let(:fake_params) { { "q" => "ruby" } }
-    let(:fake_request) { instance_double(Object) }
-    let(:fake_session) { { "token" => "abc" } }
-    let(:context) do
-      double(
-        current_user: fake_user,
-        params: fake_params,
-        request: fake_request,
-        session: fake_session
-      )
-    end
-
-    let(:query_class) do
-      Class.new(described_class) do
-        def categories
-          %w[books games]
-        end
-
-        def whoami
-          current_user
-        end
-
-        def search
-          params["q"]
-        end
-      end
-    end
-
-    describe "Story 9.4 — context accessors delegate to the injected context (AC3)" do
-      subject(:query) { query_class.new(context) }
-
-      it "exposes current_user from the context" do
-        expect(query.whoami).to eq(fake_user)
-      end
-
-      it "exposes params from the context" do
-        expect(query.search).to eq("ruby")
-      end
-
-      it "exposes request from the context" do
-        expect(query.request).to be(fake_request)
-      end
-
-      it "exposes session from the context" do
-        expect(query.session).to eq(fake_session)
-      end
-
-      it "is unit-testable with a plain fake context and no Rails boot (AC3)" do
-        expect(query_class.new(context).categories).to eq(%w[books games])
-      end
-    end
-
-    describe "Story 9.4 — accessor methods are inherited, never own methods of the subclass (AC1)" do
-      it "keeps current_user/params/request/session OUT of the subclass's public_instance_methods(false)" do
-        own = query_class.public_instance_methods(false)
-        expect(own).to contain_exactly(:categories, :whoami, :search)
-      end
-
-      it "defines the accessors on Ruact::Query itself (inherited by every subclass)" do
-        expect(described_class.public_instance_methods(false))
-          .to include(:current_user, :params, :request, :session)
-      end
-    end
-
-    describe "Story 9.4 — ruact_skip_before_action class macro (AC4 / D1)" do
-      it "records the callback with its options on the query class" do
-        klass = Class.new(described_class)
-        klass.ruact_skip_before_action(:require_login, only: :categories)
-        expect(klass.__ruact_skipped_callbacks).to eq([[[:require_login], { only: :categories }]])
-      end
-
-      it "accepts multiple callbacks in one call, mirroring Rails' skip_before_action" do
-        klass = Class.new(described_class)
-        klass.ruact_skip_before_action(:require_login, :check_tenant)
-        expect(klass.__ruact_skipped_callbacks).to eq([[%i[require_login check_tenant], {}]])
-      end
-
-      it "accumulates across calls in declaration order" do
-        klass = Class.new(described_class)
-        klass.ruact_skip_before_action(:require_login)
-        klass.ruact_skip_before_action(:check_tenant, raise: false)
-        expect(klass.__ruact_skipped_callbacks)
-          .to eq([[[:require_login], {}], [[:check_tenant], { raise: false }]])
-      end
-
-      it "keeps the recorded skips per-class — sibling query classes never share them" do
-        klass_a = Class.new(described_class)
-        klass_b = Class.new(described_class)
-        klass_a.ruact_skip_before_action(:require_login)
-        expect(klass_b.__ruact_skipped_callbacks).to be_empty
-      end
-    end
-  end
-end

data/spec/ruact/railtie_spec.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "pathname"
-require "logger"
-require "socket"
-
-# The Rails stub is provided by spec/support/rails_stub.rb.
-# We explicitly require the railtie here (was skipped in ruact.rb because
-# Rails was not defined when that file loaded).
-require "ruact/railtie"
-
-RSpec.describe Ruact::Railtie do
-  let(:missing_path) { Pathname.new("/nonexistent/path/react-client-manifest.json") }
-  let(:fake_logger) { instance_double(Logger, warn: nil, info: nil) }
-
-  before do
-    Rails.logger = fake_logger
-  end
-
-  describe ".detect_streaming_mode! (AC#1–3)" do
-    after { Ruact.streaming_mode = nil }
-
-    context "when Puma is defined" do
-      before do
-        puma = Module.new { const_set(:Server, Class.new) }
-        stub_const("Puma", puma)
-      end
-
-      it "sets streaming_mode to :enabled" do
-        described_class.detect_streaming_mode!
-        expect(Ruact.streaming_mode).to eq(:enabled)
-      end
-
-      it "logs streaming: enabled (Puma detected)" do
-        described_class.detect_streaming_mode!
-        expect(fake_logger).to have_received(:info)
-          .with(a_string_including("streaming: enabled (Puma detected)"))
-      end
-    end
-
-    context "when Unicorn is defined" do
-      before { stub_const("Unicorn", Module.new) }
-
-      it "sets streaming_mode to :buffered" do
-        described_class.detect_streaming_mode!
-        expect(Ruact.streaming_mode).to eq(:buffered)
-      end
-
-      it "logs streaming: buffered (Unicorn detected)" do
-        described_class.detect_streaming_mode!
-        expect(fake_logger).to have_received(:info)
-          .with(a_string_including("streaming: buffered (Unicorn detected)"))
-      end
-    end
-
-    context "when PhusionPassenger is defined" do
-      before { stub_const("PhusionPassenger", Module.new) }
-
-      it "sets streaming_mode to :buffered" do
-        described_class.detect_streaming_mode!
-        expect(Ruact.streaming_mode).to eq(:buffered)
-      end
-
-      it "logs streaming: buffered (Passenger detected)" do
-        described_class.detect_streaming_mode!
-        expect(fake_logger).to have_received(:info)
-          .with(a_string_including("streaming: buffered (Passenger detected)"))
-      end
-    end
-
-    context "when no recognized server constant is defined" do
-      it "sets streaming_mode to :buffered" do
-        described_class.detect_streaming_mode!
-        expect(Ruact.streaming_mode).to eq(:buffered)
-      end
-
-      it "logs server unknown — defaulting to safe mode" do
-        described_class.detect_streaming_mode!
-        expect(fake_logger).to have_received(:info)
-          .with(a_string_including("server unknown — defaulting to safe mode"))
-      end
-    end
-  end
-
-  describe ".check_manifest!" do
-    context "with missing manifest in development (AC#5, #7)" do
-      before do
-        Rails.env = ActiveSupport::StringInquirer.new("development")
-      end
-
-      it "does not raise" do
-        expect { described_class.check_manifest!(missing_path) }.not_to raise_error
-      end
-
-      it "logs a [ruact] prefixed warning" do
-        described_class.check_manifest!(missing_path)
-        expect(fake_logger).to have_received(:warn)
-          .with(a_string_starting_with("[ruact]"))
-      end
-
-      it "includes the manifest path in the warning" do
-        described_class.check_manifest!(missing_path)
-        expect(fake_logger).to have_received(:warn)
-          .with(a_string_including(missing_path.to_s))
-      end
-    end
-
-    context "with missing manifest in production (AC#6)" do
-      before { Rails.env = ActiveSupport::StringInquirer.new("production") }
-      after  { Rails.env = ActiveSupport::StringInquirer.new("development") }
-
-      it "raises ManifestError" do
-        expect { described_class.check_manifest!(missing_path) }
-          .to raise_error(Ruact::ManifestError)
-      end
-
-      it "error message contains 'run vite build before deploying'" do
-        expect { described_class.check_manifest!(missing_path) }
-          .to raise_error(Ruact::ManifestError, /run vite build before deploying/)
-      end
-    end
-  end
-
-  describe ".check_vite!" do
-    context "when Vite is running (AC#4)" do
-      before do
-        allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
-      end
-
-      it "does not log a warning" do
-        described_class.check_vite!
-        expect(fake_logger).not_to have_received(:warn)
-      end
-    end
-
-    context "when Vite is not running (AC#4)" do
-      before do
-        allow(TCPSocket).to receive(:new).and_raise(Errno::ECONNREFUSED)
-      end
-
-      it "logs a [ruact] prefixed warning" do
-        described_class.check_vite!
-        expect(fake_logger).to have_received(:warn)
-          .with(a_string_starting_with("[ruact]"))
-      end
-
-      it "mentions Vite and port 5173" do
-        described_class.check_vite!
-        expect(fake_logger).to have_received(:warn)
-          .with(a_string_including("localhost:5173"))
-      end
-    end
-  end
-end

data/spec/ruact/render_context_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Ruact
-  RSpec.describe RenderContext do
-    subject(:ctx) { described_class.new }
-
-    describe "#register" do
-      it "appends a new component entry" do
-        ctx.register("NavBar", { "currentUser" => 1 })
-        expect(ctx.components.length).to eq(1)
-        expect(ctx.components.first[:name]).to eq("NavBar")
-        expect(ctx.components.first[:props]).to eq({ "currentUser" => 1 })
-      end
-
-      it "returns a token of the form __RUACT_<index>__" do
-        token = ctx.register("Foo", {})
-        expect(token).to eq("__RUACT_0__")
-      end
-
-      it "increments token indices across successive registrations" do
-        t0 = ctx.register("A", {})
-        t1 = ctx.register("B", {})
-        t2 = ctx.register("C", {})
-        expect([t0, t1, t2]).to eq(%w[__RUACT_0__ __RUACT_1__ __RUACT_2__])
-      end
-    end
-
-    describe "#components" do
-      it "starts empty" do
-        expect(ctx.components).to eq([])
-      end
-    end
-
-    describe "#by_token" do
-      it "finds a registered component by its token" do
-        ctx.register("NavBar", { "x" => 1 })
-        entry = ctx.by_token("__RUACT_0__")
-        expect(entry[:name]).to eq("NavBar")
-      end
-
-      it "returns nil for an unknown token" do
-        expect(ctx.by_token("__RUACT_99__")).to be_nil
-      end
-    end
-
-    describe "isolation" do
-      it "two contexts are independent" do
-        a = described_class.new
-        b = described_class.new
-        a.register("A", {})
-        expect(b.components).to be_empty
-        expect(a.components.length).to eq(1)
-      end
-    end
-  end
-end

data/spec/ruact/render_pipeline_concurrency_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Ruact
-  RSpec.describe "Concurrent render isolation" do
-    let(:manifest) do
-      ClientManifest.from_hash(
-        (0..7).to_h do |i|
-          ["ThreadComponent#{i}", { "id" => "/tc#{i}.js",
-                                    "name" => "ThreadComponent#{i}",
-                                    "chunks" => ["/tc#{i}.js"] }]
-        end
-      )
-    end
-
-    let(:pipeline) { RenderPipeline.new(manifest) }
-
-    # Per Story 7.1 AC4: prove thread isolation deterministically with a
-    # countdown latch (Mutex+Queue) so all threads arrive at the render call
-    # simultaneously, fixed seed for reproducibility, ≥4 threads to outnumber
-    # typical CI cores, and ≥100 iterations to expose any race that fires
-    # ≥1% of the time.
-    let(:thread_count) { 4 }
-    let(:iterations) { 100 }
-
-    def run_isolation_iteration(iter, count, pipeline)
-      srand(0xC0DE + iter)
-      ready_latch = Queue.new
-      release     = Queue.new
-      results     = Array.new(count)
-      results_mu  = Mutex.new
-
-      threads = Array.new(count) do |tid|
-        Thread.new do
-          ctx = Object.new
-          ctx.instance_variable_set(:@tid, tid)
-          binding_ctx = ctx.instance_eval { binding }
-          ready_latch << :ready
-          release.pop
-          output = pipeline.render(
-            { erb: "<ThreadComponent#{tid} thread_id={@tid} />", binding: binding_ctx },
-            mode: :string
-          )
-          results_mu.synchronize { results[tid] = output }
-        end
-      end
-
-      count.times { ready_latch.pop }
-      count.times { release << :go }
-      threads.each(&:join)
-      results
-    end
-
-    it "isolates each render's component registry from other concurrent renders" do
-      iterations.times do |iter|
-        results = run_isolation_iteration(iter, thread_count, pipeline)
-
-        results.each_with_index do |output, tid|
-          expect(output).to include_flight_row(
-            class: :import, payload: array_including("ThreadComponent#{tid}")
-          ), "iter #{iter} thread #{tid}: missing own component import"
-          expect(output).to include_flight_row(
-            class: :model, payload: array_including(hash_including("thread_id" => tid))
-          ), "iter #{iter} thread #{tid}: missing own thread_id prop"
-
-          (0...thread_count).each do |other_tid|
-            next if other_tid == tid
-
-            expect(output).not_to include_flight_row(
-              class: :import, payload: array_including("ThreadComponent#{other_tid}")
-            ), "iter #{iter} thread #{tid} leaked ThreadComponent#{other_tid}"
-          end
-        end
-      end
-    end
-  end
-end