ruact 0.0.2 → 0.0.4

data/spec/ruact/query_spec.rb

@@ -0,0 +1,105 @@
+# 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

@@ -107,9 +107,8 @@ RSpec.describe Ruact::Railtie do
     end
 
     context "with missing manifest in production (AC#6)" do
-      before do
-        Rails.env = ActiveSupport::StringInquirer.new("production")
-      end
+      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) }

data/spec/ruact/render_context_spec.rb

@@ -0,0 +1,58 @@
+# 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

@@ -0,0 +1,78 @@
+# 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