Update conditional sharing specs

Author: skryukov

lib/inertia_rails/action_filter.rb

@@ -18,7 +18,7 @@ def match?(controller)
           #{@conditional_key.inspect} option.
         MSG
 
-        raise ActionNotFound.new(message, controller, missing_action)
+        raise AbstractController::ActionNotFound.new(message, controller, missing_action)
       end
 
       @actions.include?(controller.action_name)

spec/dummy/app/controllers/inertia_conditional_sharing_controller.rb

@@ -8,30 +8,30 @@ class InertiaConditionalSharingController < ApplicationController
   end
 
   inertia_share only: :edit do
-    {only_block_prop: 1}
+    {edit_only_only_block_prop: 1}
   end
 
   inertia_share except: [:show, :index] do
-    {except_block_prop: 1}
+    {edit_only_except_block_prop: 1}
   end
 
   inertia_share if: -> { is_edit? } do
-    {if_proc_prop: 1}
+    {edit_only_if_proc_prop: 1}
   end
 
   inertia_share unless: -> { !is_edit? } do
-    {unless_proc_prop: 1}
+    {edit_only_unless_proc_prop: 1}
   end
 
-  inertia_share({only_prop: 1}, only: :edit)
+  inertia_share({edit_only_only_prop: 1}, only: :edit)
 
-  inertia_share({if_prop: 1}, if: [:is_edit?, -> { true }])
+  inertia_share({edit_only_if_prop: 1}, if: [:is_edit?, -> { true }])
 
-  inertia_share({unless_prop: 1}, unless: :not_edit?)
+  inertia_share({edit_only_unless_prop: 1}, unless: :not_edit?)
 
-  inertia_share({only_if_prop: 1}, only: :edit, if: -> { true })
+  inertia_share({edit_only_only_if_prop: 1}, only: :edit, if: -> { true })
 
-  inertia_share({except_if_prop: 1}, except: [:index, :show], if: -> { true })
+  inertia_share({edit_only_except_if_prop: 1}, except: [:index, :show], if: -> { true })
 
   def index
     render inertia: 'EmptyTestComponent', props: {

spec/inertia/action_filter_spec.rb

@@ -0,0 +1,55 @@
+# spec/lib/inertia_rails/action_filter_spec.rb
+
+require 'rails_helper'
+
+RSpec.describe InertiaRails::ActionFilter do
+  let(:controller) do
+    instance_double(
+      'ActionController::Base',
+      action_name: 'current_action',
+      class: instance_double('Class', name: 'TestController')
+    ).tap do |stub|
+      allow(stub).to receive(:available_action?).and_return(true)
+      allow(stub).to receive(:available_action?).with('nonexistent').and_return(false)
+    end
+  end
+
+  describe '#match?' do
+    context 'when action exists' do
+      it 'returns true if action matches' do
+        filter = described_class.new(:only, 'current_action')
+        expect(filter.match?(controller)).to be true
+      end
+
+      it 'returns false if action does not match' do
+        filter = described_class.new(:only, 'other_action')
+        expect(filter.match?(controller)).to be false
+      end
+
+      it 'handles multiple actions' do
+        filter = described_class.new(:only, %w[current_action other actions])
+        expect(filter.match?(controller)).to be true
+      end
+
+      it 'handles symbol actions' do
+        filter = described_class.new(:only, :current_action)
+        expect(filter.match?(controller)).to be true
+      end
+    end
+
+    context 'when action does not exist' do
+      it 'raises ActionNotFound with appropriate message' do
+        filter = described_class.new(:only, :nonexistent)
+        expected_message = <<~MSG
+          The nonexistent action could not be found for the :inertia_share
+          callback on TestController, but it is listed in the controller's
+          :only option.
+        MSG
+
+        expect {
+          filter.match?(controller)
+        }.to raise_error(AbstractController::ActionNotFound, expected_message)
+      end
+    end
+  end
+end

spec/inertia/conditional_sharing_spec.rb

@@ -2,32 +2,43 @@
 # but it can be done by referencing the action name in an inertia_share block.
 RSpec.describe "conditionally shared data in a controller", type: :request do
   context "when there is data inside inertia_share only applicable to a single action" do
-    it "does not leak the data between requests" do
-      get conditional_share_show_path, headers: {'X-Inertia' => true}
-      expect(JSON.parse(response.body)['props'].deep_symbolize_keys).to eq({
-        normal_shared_prop: 1,
+    let(:edit_only_props) do
+      {
+        edit_only_only_block_prop: 1,
+        edit_only_except_block_prop: 1,
+        edit_only_if_proc_prop: 1,
+        edit_only_unless_proc_prop: 1,
+        edit_only_only_prop: 1,
+        edit_only_if_prop: 1,
+        edit_only_unless_prop: 1,
+        edit_only_only_if_prop: 1,
+        edit_only_except_if_prop: 1,
+        edit_only_prop: 1,
+      }
+    end
+
+    let(:show_only_props) do
+      {
         show_only_prop: 1,
         conditionally_shared_show_prop: 1,
-      })
+      }
+    end
+
+    let(:index_only_props) do
+      {
+        index_only_prop: 1,
+      }
+    end
+
+    it "does not leak the data between requests" do
+      get conditional_share_show_path, headers: {'X-Inertia' => true}
+      expect(JSON.parse(response.body)['props'].deep_symbolize_keys).to eq(show_only_props.merge(normal_shared_prop: 1))
 
       get conditional_share_index_path, headers: {'X-Inertia' => true}
-      expect(JSON.parse(response.body)['props'].deep_symbolize_keys).not_to include({
-        conditionally_shared_show_prop: 1,
-      })
+      expect(JSON.parse(response.body)['props'].deep_symbolize_keys).to eq(index_only_props.merge(normal_shared_prop: 1))
+
       get conditional_share_edit_path, headers: { 'X-Inertia' => true }
-      expect(JSON.parse(response.body)['props'].deep_symbolize_keys).to eq({
-        normal_shared_prop: 1,
-        only_block_prop: 1,
-        except_block_prop: 1,
-        if_proc_prop: 1,
-        unless_proc_prop: 1,
-        only_prop: 1,
-        if_prop: 1,
-        unless_prop: 1,
-        only_if_prop: 1,
-        except_if_prop: 1,
-        edit_only_prop: 1,
-      })
+      expect(JSON.parse(response.body)['props'].deep_symbolize_keys).to eq(edit_only_props.merge(normal_shared_prop: 1))
     end
   end