plutonium 0.46.0 → 0.48.0

data/lib/plutonium/core/controller.rb

@@ -87,11 +87,17 @@ module Plutonium
       #
       # @return [Hash] args to pass to `url_for`
       #
-      def resource_url_args_for(*args, action: nil, parent: nil, association: nil, package: nil, **kwargs)
+      def resource_url_args_for(*args, action: nil, parent: nil, association: nil, package: nil, interaction: nil, **kwargs)
         element = args.first
 
         raise ArgumentError, "parent is required when using symbol association name" if element.is_a?(Symbol) && parent.nil?
 
+        if interaction
+          raise ArgumentError, "cannot pass both `interaction:` and `action:`" if action
+          action = interactive_action_type_for(element, ids: kwargs[:ids])
+          kwargs[:interactive_action] = interaction
+        end
+
         # For nested resources, use named route helpers to avoid Rails param recall ambiguity
         if parent.present?
           assoc_name = if element.is_a?(Symbol)
@@ -137,6 +143,17 @@ module Plutonium
 
       private
 
+      # Determine the interactive action type for the given element.
+      # Records → :interactive_record_action, classes/symbols with :ids → :interactive_bulk_action,
+      # otherwise :interactive_resource_action.
+      def interactive_action_type_for(element, ids: nil)
+        if element.is_a?(Class) || element.is_a?(Symbol) || element.nil?
+          ids.present? ? :interactive_bulk_action : :interactive_resource_action
+        else
+          :interactive_record_action
+        end
+      end
+
       def build_nested_resource_url_args(element, parent:, association_name:, route_config:, action: nil, **kwargs)
         prefix = Plutonium::Routing::NESTED_ROUTE_PREFIX
         is_singular = route_config[:route_type] == :resource

data/lib/plutonium/helpers/turbo_stream_actions_helper.rb

@@ -2,7 +2,26 @@ module Plutonium
   module Helpers
     module TurboStreamActionsHelper
       def turbo_stream_redirect(url)
-        turbo_stream_action_tag :redirect, url:
+        if turbo_stream_redirect_same_page?(url)
+          turbo_stream_action_tag :refresh
+        else
+          turbo_stream_action_tag :redirect, url:
+        end
+      end
+
+      private
+
+      def turbo_stream_redirect_same_page?(url)
+        return false if request.referer.blank?
+        turbo_stream_redirect_normalize_url(url) == turbo_stream_redirect_normalize_url(request.referer)
+      end
+
+      def turbo_stream_redirect_normalize_url(url)
+        uri = URI.parse(url.to_s)
+        path = uri.path.to_s.chomp("/").presence || "/"
+        [path, uri.query].compact.join("?")
+      rescue URI::InvalidURIError
+        url.to_s
       end
     end
   end

data/lib/plutonium/testing/auth_helpers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Testing
+    module AuthHelpers
+      extend ActiveSupport::Concern
+
+      def login_as(account, portal: nil)
+        portal ||= current_portal
+        if respond_to?(:sign_in_for_tests)
+          sign_in_for_tests(account, portal: portal)
+        else
+          default_rodauth_login(account, portal: portal)
+        end
+        instance_variable_set(:"@__current_account_#{portal}", account)
+      end
+
+      def sign_out(portal: nil)
+        portal ||= current_portal
+        post logout_path_for(portal)
+        follow_redirect! if response.redirect?
+        instance_variable_set(:"@__current_account_#{portal}", nil)
+      end
+
+      def current_account(portal: nil)
+        portal ||= current_portal
+        instance_variable_get(:"@__current_account_#{portal}")
+      end
+
+      def with_portal(portal)
+        prev = @__portal_override
+        @__portal_override = portal
+        yield
+      ensure
+        @__portal_override = prev
+      end
+
+      private
+
+      def default_rodauth_login(account, portal:)
+        post login_path_for(portal), params: {email: account.email, password: "password123"}
+        follow_redirect! if response.redirect?
+      end
+
+      def login_path_for(portal)
+        "/#{account_table_for(portal)}/login"
+      end
+
+      def logout_path_for(portal)
+        "/#{account_table_for(portal)}/logout"
+      end
+
+      def account_table_for(portal)
+        case portal
+        when :admin then "admins"
+        when :user, :org then "users"
+        else portal.to_s.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/testing/dsl.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Testing
+    module DSL
+      extend ActiveSupport::Concern
+
+      class PortalNotFound < StandardError; end
+
+      DEFAULT_ACTIONS = %i[index show new create edit update destroy].freeze
+
+      class_methods do
+        def resource_tests_for(resource_class, portal:, path_prefix: nil, parent: nil,
+          actions: DEFAULT_ACTIONS, skip: [],
+          associated_with: nil, sgid_routing: false, has_cents: [])
+          @resource_tests_config = {
+            resource: resource_class,
+            portal: portal,
+            path_prefix: path_prefix || resolve_portal_path_prefix(portal),
+            parent: parent,
+            actions: actions,
+            skip: skip,
+            associated_with: associated_with,
+            sgid_routing: sgid_routing,
+            has_cents: has_cents
+          }
+        end
+
+        def resource_tests_config
+          @resource_tests_config or raise "resource_tests_for not called on #{name}"
+        end
+
+        private
+
+        def resolve_portal_path_prefix(portal_sym)
+          engine_name = "#{portal_sym.to_s.camelize}Portal::Engine"
+          engine_const = engine_name.safe_constantize
+          unless engine_const
+            raise PortalNotFound, "Could not resolve portal :#{portal_sym} (looked for #{engine_name})"
+          end
+
+          mount = find_engine_mount(engine_const)
+          unless mount
+            raise PortalNotFound, "Engine #{engine_const} is not mounted in routes"
+          end
+
+          mount.path.spec.to_s.sub(/\(\.:format\)\z/, "").chomp("/")
+        end
+
+        def find_engine_mount(engine_const)
+          Rails.application.routes.routes.find do |route|
+            matches_engine?(route.app, engine_const)
+          end
+        end
+
+        def matches_engine?(app, engine_const)
+          return true if app == engine_const
+          return false unless app.respond_to?(:app)
+          return false if app.app == app
+          matches_engine?(app.app, engine_const)
+        end
+      end
+
+      def current_portal
+        @__portal_override || self.class.resource_tests_config.fetch(:portal)
+      end
+
+      def current_path_prefix
+        self.class.resource_tests_config.fetch(:path_prefix)
+      end
+    end
+  end
+end

data/lib/plutonium/testing/nested_resource.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "plutonium/testing/dsl"
+require "plutonium/testing/auth_helpers"
+
+module Plutonium
+  module Testing
+    module NestedResource
+      extend ActiveSupport::Concern
+      include Plutonium::Testing::DSL
+      include Plutonium::Testing::AuthHelpers
+
+      class_methods do
+        def resource_tests_for(*args, **kwargs)
+          super
+          install_nested_tests!
+        end
+
+        def install_nested_tests!
+          test "nested: index lists records from current parent" do
+            create_resource!(parent: parent_record!)
+            get scoped_index_path(parent_record!)
+            assert_response :success
+          end
+
+          test "nested: show on sibling-tenant record returns 404" do
+            sibling = create_resource!(parent: other_parent_record!)
+            get "#{scoped_index_path(parent_record!)}/#{sibling.id}"
+            assert_includes [404, 302], response.status,
+              "Expected sibling-tenant record to be inaccessible (404 or redirect), got #{response.status}"
+          end
+        end
+      end
+
+      def parent_record!
+        raise NotImplementedError, "Override #parent_record! to return the current tenant"
+      end
+
+      def other_parent_record!
+        raise NotImplementedError, "Override #other_parent_record! to return a sibling tenant"
+      end
+
+      def create_resource!(parent:)
+        raise NotImplementedError, "Override #create_resource!(parent:) to return a persisted record under the given parent"
+      end
+
+      private
+
+      def scoped_index_path(parent)
+        "#{current_path_prefix}/#{parent.id}/#{resource_collection}"
+      end
+
+      def resource_collection
+        self.class.resource_tests_config.fetch(:resource).model_name.collection
+      end
+    end
+  end
+end

data/lib/plutonium/testing/portal_access.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "plutonium/testing/auth_helpers"
+
+module Plutonium
+  module Testing
+    module PortalAccess
+      extend ActiveSupport::Concern
+      include Plutonium::Testing::AuthHelpers
+
+      class_methods do
+        attr_reader :portal_access_config
+
+        def portal_access_for(portals:, matrix:)
+          @portal_access_config = {portals: portals, matrix: matrix}
+          install_portal_access_tests!
+        end
+
+        def install_portal_access_tests!
+          cfg = portal_access_config
+          cfg[:matrix].each do |role_sym, allowed_portals|
+            cfg[:portals].each do |portal_sym|
+              expected_allow = allowed_portals.include?(portal_sym)
+              test "portal access: #{role_sym} -> #{portal_sym} (#{expected_allow ? "allowed" : "blocked"})" do
+                login_as_role(role_sym)
+                get portal_root_path(portal_sym)
+                if expected_allow
+                  assert_includes [200, 302], response.status,
+                    "Expected #{role_sym} to access #{portal_sym}, got #{response.status}"
+                else
+                  assert_includes [302, 401, 403, 404], response.status,
+                    "Expected #{role_sym} blocked from #{portal_sym}, got #{response.status}"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def login_as_role(role_sym)
+        raise NotImplementedError, "Override #login_as_role(role_sym) to log in the given role"
+      end
+
+      def portal_root_path(portal_sym)
+        raise NotImplementedError, "Override #portal_root_path(portal_sym) to return the URL"
+      end
+    end
+  end
+end

data/lib/plutonium/testing/resource_crud.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "plutonium/testing/dsl"
+require "plutonium/testing/auth_helpers"
+
+module Plutonium
+  module Testing
+    module ResourceCrud
+      extend ActiveSupport::Concern
+      include Plutonium::Testing::DSL
+      include Plutonium::Testing::AuthHelpers
+
+      class_methods do
+        def resource_tests_for(*args, **kwargs)
+          super
+          install_crud_tests!
+        end
+
+        def install_crud_tests!
+          define_crud_test :index do
+            create_resource!
+            get "#{current_path_prefix}/#{resource_path}"
+            assert_response :success
+          end
+
+          define_crud_test :show do
+            record = create_resource!
+            get "#{current_path_prefix}/#{resource_path}/#{record.id}"
+            assert_response :success
+          end
+
+          define_crud_test :new do
+            get "#{current_path_prefix}/#{resource_path}/new"
+            assert_response :success
+          end
+
+          define_crud_test :create do
+            assert_difference -> { resource_class.count }, 1 do
+              post "#{current_path_prefix}/#{resource_path}", params: {param_key => valid_create_params}
+            end
+            assert_response :redirect
+          end
+
+          define_crud_test :edit do
+            record = create_resource!
+            get "#{current_path_prefix}/#{resource_path}/#{record.id}/edit"
+            assert_response :success
+          end
+
+          define_crud_test :update do
+            record = create_resource!
+            patch "#{current_path_prefix}/#{resource_path}/#{record.id}", params: {param_key => valid_update_params}
+            assert_response :redirect
+            valid_update_params.each do |attr, value|
+              next if value.is_a?(String) && value.start_with?("gid://")  # skip SGID assoc fields
+              assert_equal value, record.reload.public_send(attr),
+                "Expected ##{attr} to be updated to #{value.inspect}"
+            end
+          end
+
+          define_crud_test :destroy do
+            record = create_resource!
+            assert_difference -> { resource_class.count }, -1 do
+              delete "#{current_path_prefix}/#{resource_path}/#{record.id}"
+            end
+          end
+        end
+
+        def define_crud_test(action, &block)
+          cfg = resource_tests_config
+          return unless cfg[:actions].include?(action)
+          return if cfg[:skip].include?(action)
+          test("crud: #{action}", &block)
+        end
+      end
+
+      def create_resource!
+        raise NotImplementedError, "Override #create_resource! to return a persisted record"
+      end
+
+      def valid_create_params
+        raise NotImplementedError, "Override #valid_create_params to return a Hash of valid attributes for POST"
+      end
+
+      def valid_update_params
+        raise NotImplementedError, "Override #valid_update_params to return a Hash of valid attributes for PATCH"
+      end
+
+      private
+
+      def resource_class
+        self.class.resource_tests_config.fetch(:resource)
+      end
+
+      def resource_path
+        resource_class.model_name.collection
+      end
+
+      def param_key
+        resource_class.model_name.param_key
+      end
+    end
+  end
+end

data/lib/plutonium/testing/resource_definition.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "plutonium/testing/dsl"
+
+module Plutonium
+  module Testing
+    module ResourceDefinition
+      extend ActiveSupport::Concern
+      include Plutonium::Testing::DSL
+
+      class_methods do
+        def resource_tests_for(*args, **kwargs)
+          super
+          install_definition_tests!
+        end
+
+        def install_definition_tests!
+          test "definition: class is constantize-able" do
+            assert definition_class, "Expected #{resource_class}Definition to exist"
+          end
+
+          test "definition: every defineable prop dictionary is queryable" do
+            klass = definition_class
+            klass._defineable_props_store.each do |prop_plural|
+              dict = klass.public_send("defined_#{prop_plural}")
+              assert dict.is_a?(Hash), "defined_#{prop_plural} must be Hash, got #{dict.class}"
+            end
+          end
+
+          test "definition: declared fields exist on the model" do
+            klass = definition_class
+            return unless klass.respond_to?(:defined_fields)
+            klass.defined_fields.each_key do |field_name|
+              next if field_name == :id
+              assert resource_class.column_names.include?(field_name.to_s) ||
+                     resource_class.method_defined?(field_name) ||
+                     resource_class.reflect_on_association(field_name),
+                "Field :#{field_name} declared in #{klass} but not defined on #{resource_class}"
+            end
+          end
+        end
+
+        def resource_class
+          resource_tests_config.fetch(:resource)
+        end
+
+        def definition_class
+          @definition_class ||= "#{resource_class.name}Definition".constantize
+        end
+      end
+
+      def resource_class
+        self.class.resource_class
+      end
+
+      def definition_class
+        self.class.definition_class
+      end
+    end
+  end
+end

data/lib/plutonium/testing/resource_interaction.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Testing
+    module ResourceInteraction
+      extend ActiveSupport::Concern
+
+      class MockViewContext
+        def controller = @controller ||= MockController.new
+
+        class MockController
+          def helpers = @helpers ||= MockHelpers.new
+
+          class MockHelpers
+            def current_user = nil
+          end
+        end
+      end
+
+      def assert_interaction_success(klass, **input)
+        outcome = build_interaction(klass, **input).call
+        assert outcome.success?, "Expected #{klass} to succeed, got #{outcome.inspect}"
+        outcome
+      end
+
+      def assert_interaction_failure(klass, **input)
+        outcome = build_interaction(klass, **input).call
+        assert outcome.failure?, "Expected #{klass} to fail, got #{outcome.inspect}"
+        outcome
+      end
+
+      def interaction_view_context
+        MockViewContext.new
+      end
+
+      def interaction_class
+        raise NotImplementedError, "Override #interaction_class to return the interaction under test"
+      end
+
+      def valid_interaction_input
+        raise NotImplementedError, "Override #valid_interaction_input to return a Hash of valid input"
+      end
+
+      private
+
+      def build_interaction(klass, **input)
+        klass.new(view_context: interaction_view_context, **input)
+      end
+    end
+  end
+end

data/lib/plutonium/testing/resource_model.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "plutonium/testing/dsl"
+
+module Plutonium
+  module Testing
+    module ResourceModel
+      extend ActiveSupport::Concern
+      include Plutonium::Testing::DSL
+
+      class_methods do
+        def resource_tests_for(*args, **kwargs)
+          super
+          install_model_tests!
+        end
+
+        def install_model_tests!
+          cfg = resource_tests_config
+
+          if (assoc = cfg[:associated_with])
+            test "model: associated_with(#{assoc}) scope filters records" do
+              record = model_test_record
+              parent = record.public_send(assoc)
+              scoped = record.class.associated_with(parent)
+              assert_includes scoped.to_a, record
+            end
+          end
+
+          if cfg[:sgid_routing]
+            test "model: SGID round-trip locates record" do
+              record = model_test_record
+              sgid = record.to_sgid.to_s
+              found = GlobalID::Locator.locate_signed(sgid)
+              assert_equal record, found
+            end
+          end
+
+          Array(cfg[:has_cents]).each do |attr|
+            test "model: has_cents :#{attr} provides cents accessor" do
+              record = model_test_record
+              assert record.respond_to?(attr), "Expected ##{attr}"
+              assert record.respond_to?("#{attr}_cents"), "Expected ##{attr}_cents"
+            end
+          end
+        end
+      end
+
+      def model_test_record
+        raise NotImplementedError, "Override #model_test_record to return a persisted record"
+      end
+    end
+  end
+end

data/lib/plutonium/testing/resource_policy.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "plutonium/testing/dsl"
+
+module Plutonium
+  module Testing
+    module ResourcePolicy
+      extend ActiveSupport::Concern
+      include Plutonium::Testing::DSL
+
+      class_methods do
+        def resource_tests_for(*args, **kwargs)
+          super
+          install_policy_tests!
+        end
+
+        def install_policy_tests!
+          test "policy: matrix is asserted for every (action × role)" do
+            matrix = policy_matrix
+            roles = policy_roles
+            record = policy_record
+            policy_klass = policy_class_for(record)
+
+            matrix.each do |action, allowed_roles|
+              roles.each do |role_sym, account_proc|
+                account = instance_exec(&account_proc)
+                policy = policy_klass.new(record: record, user: account, **policy_context)
+                expected = allowed_roles.include?(role_sym)
+                actual = policy.public_send("#{action}?")
+                assert_equal expected, actual,
+                  "#{policy_klass}#{action}? for #{role_sym}: expected #{expected}, got #{actual}"
+              end
+            end
+          end
+
+          test "policy: relation_scope returns AR::Relation per role" do
+            record = policy_record
+            policy_klass = policy_class_for(record)
+            policy_roles.each do |role_sym, account_proc|
+              account = instance_exec(&account_proc)
+              policy = policy_klass.new(record: record.class, user: account, **policy_context)
+              scope = policy.apply_scope(record.class.all, type: :active_record_relation)
+              assert_kind_of ActiveRecord::Relation, scope, "relation_scope must return AR::Relation for #{role_sym}"
+            end
+          end
+        end
+      end
+
+      def policy_roles
+        raise NotImplementedError, "Override #policy_roles to return Hash{role_sym => -> { account }}"
+      end
+
+      def policy_record
+        raise NotImplementedError, "Override #policy_record to return a persisted record"
+      end
+
+      def policy_matrix
+        raise NotImplementedError, "Override #policy_matrix to return Hash{action_sym => [role_syms]}"
+      end
+
+      def policy_context
+        {entity_scope: nil}
+      end
+
+      private
+
+      def policy_class_for(record)
+        "#{record.class.name}Policy".constantize
+      end
+    end
+  end
+end

data/lib/plutonium/testing.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Testing
+  end
+end
+
+require "plutonium/testing/dsl"
+require "plutonium/testing/auth_helpers"
+require "plutonium/testing/resource_crud"
+require "plutonium/testing/resource_policy"
+require "plutonium/testing/resource_definition"
+require "plutonium/testing/resource_interaction"
+require "plutonium/testing/resource_model"
+require "plutonium/testing/nested_resource"
+require "plutonium/testing/portal_access"

data/lib/plutonium/ui/action_button.rb

@@ -64,7 +64,7 @@ module Plutonium
           form: {
             data: {
               turbo: @action.turbo,
-              turbo_confirm: @action.confirmation,
+              turbo_confirm: @action.confirmation.presence,
               turbo_frame: @action.turbo_frame
             }
           }

data/lib/plutonium/version.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  VERSION = "0.46.0"
+  VERSION = "0.48.0"
   NEXT_MAJOR_VERSION = VERSION.split(".").tap { |v|
     v[1] = v[1].to_i + 1
     v[2] = 0