Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Introduce Permission Sets and `Spree.permissions` to better manage ro… (#13324)
Damian Legawiec483b256af30c
diff --git a/core/app/models/spree/ability.rb b/core/app/models/spree/ability.rbindex 9d198ad1b2..83b2d4894e 100644--- a/core/app/models/spree/ability.rb+++ b/core/app/models/spree/ability.rb@@ -1,6 +1,15 @@# Implementation class for Cancan gem. Instead of overriding this class, consider adding new permissions# using the special +register_ability+ method which allows extensions to add their own abilities.#+# The preferred way to add permissions is now through permission sets. See Spree::PermissionSets::Base+# for more details on creating custom permission sets.+#+# @example Configuring role permissions+# Spree.permissions.assign(:customer_service, [+# Spree::PermissionSets::OrderDisplay,+# Spree::PermissionSets::UserManagement+# ])+## See https://github.com/CanCanCommunity/cancancan for more details.require 'cancan'@@ -11,6 +20,12 @@ module Spreeclass_attribute :abilitiesself.abilities = Set.new+ # @return [Object] the current user+ attr_reader :user++ # @return [Spree::Store, nil] the current store+ attr_reader :store+# Allows us to go beyond the standard cancan initialize method which makes it difficult for engines to# modify the default +Ability+ of an application. The +ability+ argument must be a class that includes# the +CanCan::Ability+ module. The registered ability should behave properly as a stand-alone class@@ -26,22 +41,16 @@ module Spreedef initialize(user, options = {})alias_cancan_delete_action- user ||= Spree.user_class.new- store ||= options[:store] || Spree::Current.store+ @user = user || Spree.user_class.new+ @store = options[:store] || Spree::Current.store- if user.persisted? && user.is_a?(Spree.admin_user_class) && user.try(:spree_admin?, store)- apply_admin_permissions(user, options)- else- apply_user_permissions(user, options)- end+ apply_permissions_from_sets# Include any abilities registered by extensions, etc.# this is legacy behaviour and should be removed in Spree 5.0Ability.abilities.merge(abilities_to_register).each do |clazz|- merge clazz.new(user)+ merge clazz.new(@user)end-- protect_admin_roleendprotected@@ -57,6 +66,62 @@ module Spreealias_action :create, :update, :destroy, to: :modifyend+ # Applies permissions based on the user's roles and the configured permission sets.+ def apply_permissions_from_sets+ role_names = determine_role_names+ permission_sets = Spree.permissions.permission_sets_for_roles(role_names)++ # If no permission sets are configured for the user's roles, use legacy behavior+ if permission_sets.empty?+ apply_legacy_permissions+ else+ activate_permission_sets(permission_sets)+ end+ end++ # Determines the role names for the current user.+ #+ # @return [Array<Symbol>] the role names+ def determine_role_names+ return [:default] unless @user.persisted?++ # First, try to get roles from the spree_roles association+ if @user.respond_to?(:spree_roles)+ role_names = @user.spree_roles.pluck(:name).map(&:to_sym)+ return role_names if role_names.any?+ end++ # Fall back to checking spree_admin? for backward compatibility+ # This supports cases where roles are mocked or admin status is determined differently+ if @user.try(:spree_admin?, @store)+ [:admin]+ else+ [:default]+ end+ end++ # Activates the given permission sets.+ #+ # @param permission_sets [Array<Class>] the permission set classes to activate+ def activate_permission_sets(permission_sets)+ permission_sets.each do |permission_set_class|+ permission_set = permission_set_class.new(self)+ permission_set.activate!+ end+ end++ # Legacy permission application for backward compatibility.+ # This is used when no permission sets are configured for the user's roles.+ def apply_legacy_permissions+ if @user.persisted? && @user.is_a?(Spree.admin_user_class) && @user.try(:spree_admin?, @store)+ apply_admin_permissions(@user, { store: @store })+ else+ apply_user_permissions(@user, { store: @store })+ end++ protect_admin_role+ end+def apply_admin_permissions(_user, _options)can :manage, :allcannot :cancel, Spree::Orderdiff --git a/core/app/models/spree/permission_sets/base.rb b/core/app/models/spree/permission_sets/base.rbnew file mode 100644index 0000000000..f42a9f2617--- /dev/null+++ b/core/app/models/spree/permission_sets/base.rb@@ -0,0 +1,81 @@+# Base class for all permission sets.+#+# Permission sets are reusable groups of permissions that can be assigned to roles.+# They provide a clean abstraction over CanCanCan abilities, making it easier to+# manage permissions in a modular way.+#+# @example Creating a custom permission set+# class Spree::PermissionSets::InventoryManagement < Spree::PermissionSets::Base+# def activate!+# can :manage, Spree::StockItem+# can :manage, Spree::StockLocation+# can :manage, Spree::StockMovement+# end+# end+#+# @example Assigning the permission set to a role+# Spree.permissions.assign(:warehouse_manager, Spree::PermissionSets::InventoryManagement)+#+module Spree+ module PermissionSets+ class Base+ # @return [CanCan::Ability] the ability instance to add permissions to+ attr_reader :ability++ # @param ability [CanCan::Ability] the ability instance to add permissions to+ def initialize(ability)+ @ability = ability+ end++ # Activates this permission set by adding its permissions to the ability.+ # Override this method in subclasses to define the permissions.+ #+ # @abstract+ # @return [void]+ def activate!+ raise NotImplementedError, "#{self.class} must implement #activate!"+ end++ protected++ # Delegates the `can` method to the ability instance.+ #+ # @param args [Array] arguments to pass to CanCan::Ability#can+ # @param block [Proc] optional block for conditional permissions+ def can(*args, &block)+ ability.can(*args, &block)+ end++ # Delegates the `cannot` method to the ability instance.+ #+ # @param args [Array] arguments to pass to CanCan::Ability#cannot+ # @param block [Proc] optional block for conditional permissions+ def cannot(*args, &block)+ ability.cannot(*args, &block)+ end++ # Delegates the `can?` method to the ability instance.+ #+ # @param args [Array] arguments to pass to CanCan::Ability#can?+ # @return [Boolean]+ def can?(*args)+ ability.can?(*args)+ end++ # Returns the user from the ability instance.+ # This method assumes the ability has a user accessor.+ #+ # @return [Object] the current user+ def user+ ability.user+ end++ # Returns the store from the ability instance options.+ #+ # @return [Spree::Store, nil] the current store+ def store+ ability.store+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/configuration_management.rb b/core/app/models/spree/permission_sets/configuration_management.rbnew file mode 100644index 0000000000..e3411fce5a--- /dev/null+++ b/core/app/models/spree/permission_sets/configuration_management.rb@@ -0,0 +1,47 @@+# Permission set for managing store configuration and settings.+#+# This permission set provides access to manage store settings,+# payment methods, shipping methods, and other configuration.+#+# @example+# Spree.permissions.assign(:store_admin, Spree::PermissionSets::ConfigurationManagement)+#+module Spree+ module PermissionSets+ class ConfigurationManagement < Base+ def activate!+ # Store settings+ can :manage, Spree::Store++ # Payment configuration+ can :manage, Spree::PaymentMethod+ can :manage, Spree::Gateway++ # Shipping configuration+ can :manage, Spree::ShippingMethod+ can :manage, Spree::ShippingCategory+ can :manage, Spree::Zone+ can :manage, Spree::ZoneMember++ # Tax configuration+ can :manage, Spree::TaxCategory+ can :manage, Spree::TaxRate++ # General configuration+ can :manage, Spree::RefundReason+ can :manage, Spree::ReimbursementType+ can :manage, Spree::ReturnReason++ # Restrictions on immutable types+ cannot [:edit, :update], Spree::RefundReason, mutable: false+ cannot [:edit, :update], Spree::ReimbursementType, mutable: false++ # Metafield configuration+ can :manage, Spree::MetafieldDefinition++ # Policies+ can :manage, Spree::Policy+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/dashboard_display.rb b/core/app/models/spree/permission_sets/dashboard_display.rbnew file mode 100644index 0000000000..ddf680e75f--- /dev/null+++ b/core/app/models/spree/permission_sets/dashboard_display.rb@@ -0,0 +1,17 @@+# Permission set for viewing the admin dashboard.+#+# This permission set provides access to view the admin dashboard+# and basic admin navigation.+#+# @example+# Spree.permissions.assign(:viewer, Spree::PermissionSets::DashboardDisplay)+#+module Spree+ module PermissionSets+ class DashboardDisplay < Base+ def activate!+ can [:admin, :index, :show], :dashboard+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/default_customer.rb b/core/app/models/spree/permission_sets/default_customer.rbnew file mode 100644index 0000000000..138a1d6b85--- /dev/null+++ b/core/app/models/spree/permission_sets/default_customer.rb@@ -0,0 +1,66 @@+# Permission set for default storefront customers (both authenticated and guests).+#+# This permission set provides the standard permissions needed for browsing+# the store and making purchases.+#+# @example+# Spree.permissions.assign(:default, Spree::PermissionSets::DefaultCustomer)+#+module Spree+ module PermissionSets+ class DefaultCustomer < Base+ def activate!+ # Read-only access to catalog+ can :read, Spree::Country+ can :read, Spree::OptionType+ can :read, Spree::OptionValue+ can :read, Spree::Product+ can :read, Spree::ProductProperty+ can :read, Spree::Property+ can :read, Spree::State+ can :read, Spree::Store+ can :read, Spree::Taxon+ can :read, Spree::Taxonomy+ can :read, Spree::Variant+ can :read, Spree::Zone++ # Content pages+ can :read, Spree::Policy+ can :read, Spree::Page+ can :read, Spree::Post+ can :read, Spree::PostCategory++ # Order management for the user's own orders+ can :create, Spree::Order+ can :show, Spree::Order do |order, token|+ order.user == user || order.token && token == order.token+ end+ can :update, Spree::Order do |order, token|+ !order.completed? && (order.user == user || order.token && token == order.token)+ end++ # User account management - available to all users (including guests for their own record)+ can :create, Spree.user_class+ can [:show, :update, :destroy], Spree.user_class, id: user.id++ # Address management+ can :manage, Spree::Address, user_id: user.id++ # Credit card management+ can [:read, :destroy], Spree::CreditCard, user_id: user.id++ # Wishlist management+ can :manage, Spree::Wishlist, user_id: user.id+ can :show, Spree::Wishlist do |wishlist|+ wishlist.user == user || wishlist.is_private == false+ end+ can [:create, :update, :destroy], Spree::WishedItem do |wished_item|+ wished_item.wishlist.user == user+ end++ # Invitation acceptance+ can :accept, Spree::Invitation, invitee_id: [user.id, nil], invitee_type: user.class.name, status: 'pending'+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/order_display.rb b/core/app/models/spree/permission_sets/order_display.rbnew file mode 100644index 0000000000..dd3588f56c--- /dev/null+++ b/core/app/models/spree/permission_sets/order_display.rb@@ -0,0 +1,27 @@+# Permission set for viewing orders and related resources.+#+# This permission set provides read-only access to orders and associated+# models like payments, shipments, and refunds.+#+# @example+# Spree.permissions.assign(:customer_service, Spree::PermissionSets::OrderDisplay)+#+module Spree+ module PermissionSets+ class OrderDisplay < Base+ def activate!+ can [:read, :admin, :index], Spree::Order+ can [:read, :admin], Spree::Payment+ can [:read, :admin], Spree::Shipment+ can [:read, :admin], Spree::Adjustment+ can [:read, :admin], Spree::LineItem+ can [:read, :admin], Spree::ReturnAuthorization+ can [:read, :admin], Spree::CustomerReturn+ can [:read, :admin], Spree::Reimbursement+ can [:read, :admin], Spree::Refund+ can [:read, :admin], Spree::StoreCredit+ can [:read, :admin], Spree::GiftCard+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/order_management.rb b/core/app/models/spree/permission_sets/order_management.rbnew file mode 100644index 0000000000..2d2076cfc0--- /dev/null+++ b/core/app/models/spree/permission_sets/order_management.rb@@ -0,0 +1,33 @@+# Permission set for full order management.+#+# This permission set provides complete access to manage orders,+# including creating, updating, and processing payments and shipments.+#+# @example+# Spree.permissions.assign(:order_manager, Spree::PermissionSets::OrderManagement)+#+module Spree+ module PermissionSets+ class OrderManagement < Base+ def activate!+ can :manage, Spree::Order+ can :manage, Spree::Payment+ can :manage, Spree::Shipment+ can :manage, Spree::Adjustment+ can :manage, Spree::LineItem+ can :manage, Spree::ReturnAuthorization+ can :manage, Spree::CustomerReturn+ can :manage, Spree::Reimbursement+ can :manage, Spree::Refund+ can :manage, Spree::StoreCredit+ can :manage, Spree::GiftCard++ # Order-specific restrictions+ cannot :cancel, Spree::Order+ can :cancel, Spree::Order, &:allow_cancel?+ cannot :destroy, Spree::Order+ can :destroy, Spree::Order, &:can_be_deleted?+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/product_display.rb b/core/app/models/spree/permission_sets/product_display.rbnew file mode 100644index 0000000000..7a3f6f8abe--- /dev/null+++ b/core/app/models/spree/permission_sets/product_display.rb@@ -0,0 +1,27 @@+# Permission set for viewing products and catalog information.+#+# This permission set provides read-only access to products, variants,+# and related catalog models.+#+# @example+# Spree.permissions.assign(:content_editor, Spree::PermissionSets::ProductDisplay)+#+module Spree+ module PermissionSets+ class ProductDisplay < Base+ def activate!+ can [:read, :admin, :index], Spree::Product+ can [:read, :admin], Spree::Variant+ can [:read, :admin], Spree::OptionType+ can [:read, :admin], Spree::OptionValue+ can [:read, :admin], Spree::Property+ can [:read, :admin], Spree::ProductProperty+ can [:read, :admin], Spree::Metafield+ can [:read, :admin], Spree::Taxon+ can [:read, :admin], Spree::Taxonomy+ can [:read, :admin], Spree::Classification+ can [:read, :admin], Spree::Price+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/product_management.rb b/core/app/models/spree/permission_sets/product_management.rbnew file mode 100644index 0000000000..8ee1b38023--- /dev/null+++ b/core/app/models/spree/permission_sets/product_management.rb@@ -0,0 +1,27 @@+# Permission set for full product and catalog management.+#+# This permission set provides complete access to manage products, variants,+# and related catalog models like taxonomies and properties.+#+# @example+# Spree.permissions.assign(:merchandiser, Spree::PermissionSets::ProductManagement)+#+module Spree+ module PermissionSets+ class ProductManagement < Base+ def activate!+ can :manage, Spree::Product+ can :manage, Spree::Variant+ can :manage, Spree::OptionType+ can :manage, Spree::OptionValue+ can :manage, Spree::Property+ can :manage, Spree::ProductProperty+ can :manage, Spree::Taxon+ can :manage, Spree::Taxonomy+ can :manage, Spree::Classification+ can :manage, Spree::Price+ can :manage, Spree::Asset+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/promotion_management.rb b/core/app/models/spree/permission_sets/promotion_management.rbnew file mode 100644index 0000000000..a1d7e5f33f--- /dev/null+++ b/core/app/models/spree/permission_sets/promotion_management.rb@@ -0,0 +1,22 @@+# Permission set for managing promotions and discounts.+#+# This permission set provides access to create and manage promotions,+# coupon codes, and promotion rules.+#+# @example+# Spree.permissions.assign(:marketing, Spree::PermissionSets::PromotionManagement)+#+module Spree+ module PermissionSets+ class PromotionManagement < Base+ def activate!+ can :manage, Spree::Promotion+ can :manage, Spree::PromotionRule+ can :manage, Spree::PromotionAction+ can :manage, Spree::PromotionCategory+ can :manage, Spree::CouponCode+ can [:read, :admin], Spree::Metafield+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/role_management.rb b/core/app/models/spree/permission_sets/role_management.rbnew file mode 100644index 0000000000..f817d94115--- /dev/null+++ b/core/app/models/spree/permission_sets/role_management.rb@@ -0,0 +1,21 @@+# Permission set for managing roles and permissions.+#+# This permission set provides access to manage roles and user assignments.+# Note: The admin role cannot be modified.+#+# @example+# Spree.permissions.assign(:admin, Spree::PermissionSets::RoleManagement)+#+module Spree+ module PermissionSets+ class RoleManagement < Base+ def activate!+ can :manage, Spree::Role+ can :manage, Spree::RoleUser++ # Protect the admin role from modification+ cannot [:update, :destroy], Spree::Role, name: ['admin']+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/stock_display.rb b/core/app/models/spree/permission_sets/stock_display.rbnew file mode 100644index 0000000000..a123647493--- /dev/null+++ b/core/app/models/spree/permission_sets/stock_display.rb@@ -0,0 +1,19 @@+# Permission set for viewing stock and inventory information.+#+# This permission set provides read-only access to stock items,+# locations, and movements.+#+# @example+# Spree.permissions.assign(:warehouse_viewer, Spree::PermissionSets::StockDisplay)+#+module Spree+ module PermissionSets+ class StockDisplay < Base+ def activate!+ can [:read, :admin, :index], Spree::StockItem+ can [:read, :admin], Spree::StockLocation+ can [:read, :admin], Spree::StockMovement+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/stock_management.rb b/core/app/models/spree/permission_sets/stock_management.rbnew file mode 100644index 0000000000..ac2e841bf3--- /dev/null+++ b/core/app/models/spree/permission_sets/stock_management.rb@@ -0,0 +1,19 @@+# Permission set for full stock and inventory management.+#+# This permission set provides complete access to manage stock items,+# locations, and movements.+#+# @example+# Spree.permissions.assign(:warehouse_manager, Spree::PermissionSets::StockManagement)+#+module Spree+ module PermissionSets+ class StockManagement < Base+ def activate!+ can :manage, Spree::StockItem+ can :manage, Spree::StockLocation+ can :manage, Spree::StockMovement+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/super_user.rb b/core/app/models/spree/permission_sets/super_user.rbnew file mode 100644index 0000000000..842b9a3e1e--- /dev/null+++ b/core/app/models/spree/permission_sets/super_user.rb@@ -0,0 +1,28 @@+# Permission set granting full administrative access.+#+# This permission set provides unrestricted access to all resources,+# with some safety restrictions for critical operations.+#+# @example+# Spree.permissions.assign(:admin, Spree::PermissionSets::SuperUser)+#+module Spree+ module PermissionSets+ class SuperUser < Base+ def activate!+ can :manage, :all++ # Safety restrictions+ cannot :cancel, Spree::Order+ can :cancel, Spree::Order, &:allow_cancel?+ cannot :destroy, Spree::Order+ can :destroy, Spree::Order, &:can_be_deleted?+ cannot [:edit, :update], Spree::RefundReason, mutable: false+ cannot [:edit, :update], Spree::ReimbursementType, mutable: false++ # Protect the admin role from modification+ cannot [:update, :destroy], Spree::Role, name: ['admin']+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/user_display.rb b/core/app/models/spree/permission_sets/user_display.rbnew file mode 100644index 0000000000..1aa3911e25--- /dev/null+++ b/core/app/models/spree/permission_sets/user_display.rb@@ -0,0 +1,19 @@+# Permission set for viewing users and related information.+#+# This permission set provides read-only access to user accounts,+# addresses, and credit cards.+#+# @example+# Spree.permissions.assign(:support_staff, Spree::PermissionSets::UserDisplay)+#+module Spree+ module PermissionSets+ class UserDisplay < Base+ def activate!+ can [:read, :admin, :index], Spree.user_class+ can [:read, :admin], Spree::Address+ can [:read, :admin], Spree::CreditCard+ end+ end+ end+enddiff --git a/core/app/models/spree/permission_sets/user_management.rb b/core/app/models/spree/permission_sets/user_management.rbnew file mode 100644index 0000000000..f59df27d78--- /dev/null+++ b/core/app/models/spree/permission_sets/user_management.rb@@ -0,0 +1,20 @@+# Permission set for full user management.+#+# This permission set provides complete access to manage user accounts,+# addresses, and credit cards.+#+# @example+# Spree.permissions.assign(:customer_service, Spree::PermissionSets::UserManagement)+#+module Spree+ module PermissionSets+ class UserManagement < Base+ def activate!+ can :manage, Spree.user_class+ can :manage, Spree::Address+ can :manage, Spree::CreditCard+ can [:read, :admin], Spree::Metafield+ end+ end+ end+enddiff --git a/core/lib/generators/spree/install/templates/config/initializers/spree.rb b/core/lib/generators/spree/install/templates/config/initializers/spree.rbindex 1888cdae3b..36a08f6959 100644--- a/core/lib/generators/spree/install/templates/config/initializers/spree.rb+++ b/core/lib/generators/spree/install/templates/config/initializers/spree.rb@@ -95,6 +95,31 @@ Rails.application.config.after_initialize do# Admin partials# Spree.admin.partials.product_form << 'spree/admin/products/custom_section'++ # Role-based permissions+ # Configure which permission sets are assigned to each role+ # More on permission sets: https://spreecommerce.org/docs/developer/customization/permissions+ Spree.permissions.assign(:default, [Spree::PermissionSets::DefaultCustomer])+ Spree.permissions.assign(:admin, [Spree::PermissionSets::SuperUser])++ # Example: Create a custom role with specific permissions+ # Spree.permissions.assign(:customer_service, [+ # Spree::PermissionSets::DashboardDisplay,+ # Spree::PermissionSets::OrderManagement,+ # Spree::PermissionSets::UserDisplay+ # ])+ #+ # Available permission sets:+ # - Spree::PermissionSets::SuperUser (full admin access)+ # - Spree::PermissionSets::DefaultCustomer (storefront access)+ # - Spree::PermissionSets::DashboardDisplay (view admin dashboard)+ # - Spree::PermissionSets::OrderDisplay / OrderManagement+ # - Spree::PermissionSets::ProductDisplay / ProductManagement+ # - Spree::PermissionSets::UserDisplay / UserManagement+ # - Spree::PermissionSets::StockDisplay / StockManagement+ # - Spree::PermissionSets::PromotionManagement+ # - Spree::PermissionSets::ConfigurationManagement+ # - Spree::PermissionSets::RoleManagementendSpree.user_class = <%= (options[:user_class].blank? ? 'Spree::LegacyUser' : options[:user_class]).inspect %>diff --git a/core/lib/spree/core.rb b/core/lib/spree/core.rbindex fb7c046ddc..913b1e4c5b 100644--- a/core/lib/spree/core.rb+++ b/core/lib/spree/core.rb@@ -358,6 +358,22 @@ module Spreeendend+ # Permission configuration accessor for managing role-to-permission-set mappings.+ #+ # @example Assigning permission sets to a role+ # Spree.permissions.assign(:customer_service, [+ # Spree::PermissionSets::OrderDisplay,+ # Spree::PermissionSets::UserManagement+ # ])+ #+ # @example Clearing permission sets from a role+ # Spree.permissions.clear(:customer_service)+ #+ # @return [Spree::PermissionConfiguration] the permission configuration instance+ def self.permissions+ @permissions ||= PermissionConfiguration.new+ end+module Coreautoload :ProductFilters, 'spree/core/product_filters'autoload :TokenGenerator, 'spree/core/token_generator'@@ -400,3 +416,4 @@ require 'spree/core/preferences/scoped_store'require 'spree/core/preferences/runtime_configuration'require 'spree/core/webhooks'+require 'spree/core/permission_configuration'diff --git a/core/lib/spree/core/permission_configuration.rb b/core/lib/spree/core/permission_configuration.rbnew file mode 100644index 0000000000..645fc996ac--- /dev/null+++ b/core/lib/spree/core/permission_configuration.rb@@ -0,0 +1,102 @@+# Manages the mapping between roles and permission sets.+#+# This configuration allows you to define which permission sets are assigned to each role.+# Permission sets are reusable groups of permissions that can be applied to roles.+#+# @example Assigning permission sets to a role+# Spree.permissions.assign(:customer_service, [+# Spree::PermissionSets::OrderDisplay,+# Spree::PermissionSets::UserManagement+# ])+#+# @example Clearing permission sets from a role+# Spree.permissions.clear(:customer_service)+#+# @example Getting permission sets for a role+# Spree.permissions.permission_sets_for(:admin)+# # => [Spree::PermissionSets::SuperUser]+#+module Spree+ class PermissionConfiguration+ # Default role used for unauthenticated users+ DEFAULT_ROLE = :default++ # Admin role with full access+ ADMIN_ROLE = :admin++ def initialize+ @role_permissions = {}+ end++ # Assigns permission sets to a role.+ #+ # @param role_name [Symbol, String] the name of the role+ # @param permission_sets [Array<Class>, Class] permission set class(es) to assign+ # @return [Array<Class>] the assigned permission sets+ #+ # @example+ # Spree.permissions.assign(:customer_service, Spree::PermissionSets::OrderDisplay)+ # Spree.permissions.assign(:admin, [+ # Spree::PermissionSets::SuperUser+ # ])+ def assign(role_name, permission_sets)+ role_key = normalize_role_name(role_name)+ @role_permissions[role_key] ||= []+ @role_permissions[role_key] |= Array(permission_sets)+ end++ # Clears all permission sets from a role.+ #+ # @param role_name [Symbol, String] the name of the role+ # @return [Array<Class>] the removed permission sets+ def clear(role_name)+ role_key = normalize_role_name(role_name)+ @role_permissions.delete(role_key)+ end++ # Returns the permission sets assigned to a role.+ #+ # @param role_name [Symbol, String] the name of the role+ # @return [Array<Class>] the assigned permission sets+ def permission_sets_for(role_name)+ role_key = normalize_role_name(role_name)+ @role_permissions[role_key] || []+ end++ # Returns all permission sets for multiple roles.+ #+ # @param role_names [Array<Symbol, String>] the names of the roles+ # @return [Array<Class>] the combined permission sets (deduplicated)+ def permission_sets_for_roles(role_names)+ role_names.flat_map { |role_name| permission_sets_for(role_name) }.uniq+ end++ # Returns all configured roles.+ #+ # @return [Array<Symbol>] the configured role names+ def roles+ @role_permissions.keys+ end++ # Checks if a role has any permission sets assigned.+ #+ # @param role_name [Symbol, String] the name of the role+ # @return [Boolean]+ def role_configured?(role_name)+ role_key = normalize_role_name(role_name)+ @role_permissions.key?(role_key) && @role_permissions[role_key].any?+ end++ # Resets all role permissions to empty state.+ # Useful for testing.+ def reset!+ @role_permissions = {}+ end++ private++ def normalize_role_name(role_name)+ role_name.to_s.downcase.to_sym+ end+ end+enddiff --git a/core/spec/lib/spree/core/permission_configuration_spec.rb b/core/spec/lib/spree/core/permission_configuration_spec.rbnew file mode 100644index 0000000000..45a299ad15--- /dev/null+++ b/core/spec/lib/spree/core/permission_configuration_spec.rb@@ -0,0 +1,143 @@+require 'spec_helper'++RSpec.describe Spree::PermissionConfiguration do+ subject(:config) { described_class.new }++ # Create test permission set classes+ let(:permission_set_a) { Class.new(Spree::PermissionSets::Base) { def activate!; can :read, Spree::Order; end } }+ let(:permission_set_b) { Class.new(Spree::PermissionSets::Base) { def activate!; can :manage, Spree::Order; end } }+ let(:permission_set_c) { Class.new(Spree::PermissionSets::Base) { def activate!; can :read, Spree::Product; end } }++ describe '#assign' do+ it 'assigns a single permission set to a role' do+ config.assign(:customer_service, permission_set_a)++ expect(config.permission_sets_for(:customer_service)).to contain_exactly(permission_set_a)+ end++ it 'assigns multiple permission sets to a role' do+ config.assign(:customer_service, [permission_set_a, permission_set_b])++ expect(config.permission_sets_for(:customer_service)).to contain_exactly(permission_set_a, permission_set_b)+ end++ it 'adds to existing permission sets when called multiple times' do+ config.assign(:customer_service, permission_set_a)+ config.assign(:customer_service, permission_set_b)++ expect(config.permission_sets_for(:customer_service)).to contain_exactly(permission_set_a, permission_set_b)+ end++ it 'does not duplicate permission sets' do+ config.assign(:customer_service, permission_set_a)+ config.assign(:customer_service, permission_set_a)++ expect(config.permission_sets_for(:customer_service)).to contain_exactly(permission_set_a)+ end++ it 'normalizes role names to symbols' do+ config.assign('Customer_Service', permission_set_a)++ expect(config.permission_sets_for(:customer_service)).to contain_exactly(permission_set_a)+ end+ end++ describe '#clear' do+ it 'removes all permission sets from a role' do+ config.assign(:customer_service, [permission_set_a, permission_set_b])+ config.clear(:customer_service)++ expect(config.permission_sets_for(:customer_service)).to be_empty+ end++ it 'returns the removed permission sets' do+ config.assign(:customer_service, [permission_set_a, permission_set_b])++ expect(config.clear(:customer_service)).to contain_exactly(permission_set_a, permission_set_b)+ end++ it 'returns nil for non-existent roles' do+ expect(config.clear(:nonexistent)).to be_nil+ end+ end++ describe '#permission_sets_for' do+ it 'returns an empty array for non-configured roles' do+ expect(config.permission_sets_for(:unknown)).to eq([])+ end++ it 'returns the assigned permission sets' do+ config.assign(:admin, permission_set_a)++ expect(config.permission_sets_for(:admin)).to contain_exactly(permission_set_a)+ end++ it 'normalizes role names' do+ config.assign(:admin, permission_set_a)++ expect(config.permission_sets_for('ADMIN')).to contain_exactly(permission_set_a)+ end+ end++ describe '#permission_sets_for_roles' do+ it 'combines permission sets from multiple roles' do+ config.assign(:admin, permission_set_a)+ config.assign(:merchandiser, permission_set_b)++ expect(config.permission_sets_for_roles([:admin, :merchandiser])).to contain_exactly(permission_set_a, permission_set_b)+ end++ it 'deduplicates permission sets shared across roles' do+ config.assign(:admin, permission_set_a)+ config.assign(:merchandiser, [permission_set_a, permission_set_b])++ expect(config.permission_sets_for_roles([:admin, :merchandiser])).to contain_exactly(permission_set_a, permission_set_b)+ end++ it 'returns empty array when no roles have permission sets' do+ expect(config.permission_sets_for_roles([:unknown1, :unknown2])).to eq([])+ end+ end++ describe '#roles' do+ it 'returns all configured roles' do+ config.assign(:admin, permission_set_a)+ config.assign(:customer_service, permission_set_b)++ expect(config.roles).to contain_exactly(:admin, :customer_service)+ end++ it 'returns empty array when no roles are configured' do+ expect(config.roles).to eq([])+ end+ end++ describe '#role_configured?' do+ it 'returns true for configured roles' do+ config.assign(:admin, permission_set_a)++ expect(config.role_configured?(:admin)).to be true+ end++ it 'returns false for non-configured roles' do+ expect(config.role_configured?(:unknown)).to be false+ end++ it 'returns false for cleared roles' do+ config.assign(:admin, permission_set_a)+ config.clear(:admin)++ expect(config.role_configured?(:admin)).to be false+ end+ end++ describe '#reset!' do+ it 'clears all role permissions' do+ config.assign(:admin, permission_set_a)+ config.assign(:customer_service, permission_set_b)+ config.reset!++ expect(config.roles).to eq([])+ end+ end+enddiff --git a/core/spec/models/spree/permission_sets/ability_integration_spec.rb b/core/spec/models/spree/permission_sets/ability_integration_spec.rbnew file mode 100644index 0000000000..6484a460d9--- /dev/null+++ b/core/spec/models/spree/permission_sets/ability_integration_spec.rb@@ -0,0 +1,146 @@+require 'spec_helper'+require 'cancan/matchers'++RSpec.describe 'Permission Sets Integration with Ability', type: :model do+ let(:store) { create(:store) }++ before do+ # Reset permissions before each test+ Spree.permissions.reset!+ end++ after do+ # Reset permissions after each test+ Spree.permissions.reset!+ end++ describe 'role-based permissions' do+ let(:customer_service_permission_set) do+ Class.new(Spree::PermissionSets::Base) do+ def activate!+ can [:read, :admin], Spree::Order+ can [:read, :admin], Spree.user_class+ end+ end+ end++ let(:merchandiser_permission_set) do+ Class.new(Spree::PermissionSets::Base) do+ def activate!+ can :manage, Spree::Product+ can :manage, Spree::Variant+ end+ end+ end++ context 'user with single role' do+ let(:role) { create(:role, name: 'customer_service') }+ let(:user) { create(:user) }++ before do+ user.spree_roles << role+ Spree.permissions.assign(:customer_service, customer_service_permission_set)+ end++ it 'applies the permission sets for the role' do+ ability = Spree::Ability.new(user)++ expect(ability.can?(:read, Spree::Order)).to be true+ expect(ability.can?(:admin, Spree::Order)).to be true+ expect(ability.can?(:manage, Spree::Product)).to be false+ end+ end++ context 'user with multiple roles' do+ let(:cs_role) { create(:role, name: 'customer_service') }+ let(:merch_role) { create(:role, name: 'merchandiser') }+ let(:user) { create(:user) }++ before do+ user.spree_roles << cs_role+ user.spree_roles << merch_role+ Spree.permissions.assign(:customer_service, customer_service_permission_set)+ Spree.permissions.assign(:merchandiser, merchandiser_permission_set)+ end++ it 'combines permission sets from all roles' do+ ability = Spree::Ability.new(user)++ expect(ability.can?(:read, Spree::Order)).to be true+ expect(ability.can?(:manage, Spree::Product)).to be true+ end+ end++ context 'user with unconfigured role' do+ let(:role) { create(:role, name: 'unconfigured_role') }+ let(:user) { create(:user) }++ before do+ user.spree_roles << role+ # Don't configure any permission sets for this role+ end++ it 'falls back to legacy behavior' do+ ability = Spree::Ability.new(user)++ # Legacy behavior for regular users+ expect(ability.can?(:read, Spree::Product)).to be true+ expect(ability.can?(:create, Spree::Order)).to be true+ expect(ability.can?(:manage, Spree::Product)).to be false+ end+ end+ end++ describe 'default role' do+ let(:guest_user) { Spree.user_class.new }++ before do+ Spree.permissions.assign(:default, Spree::PermissionSets::DefaultCustomer)+ end++ it 'applies default permissions to non-persisted users' do+ ability = Spree::Ability.new(guest_user)++ expect(ability.can?(:read, Spree::Product)).to be true+ expect(ability.can?(:create, Spree::Order)).to be true+ expect(ability.can?(:manage, Spree::Product)).to be false+ end+ end++ describe 'admin role' do+ let(:admin_role) { Spree::Role.find_or_create_by!(name: 'admin') }+ let(:admin_user) { create(:admin_user) }++ before do+ admin_user.spree_roles << admin_role unless admin_user.spree_roles.include?(admin_role)+ Spree.permissions.assign(:admin, Spree::PermissionSets::SuperUser)+ end++ it 'applies super user permissions to admin users' do+ ability = Spree::Ability.new(admin_user)++ expect(ability.can?(:manage, :all)).to be true+ end+ end++ describe 'permission configuration API' do+ it 'allows configuring permissions like Solidus' do+ Spree.permissions.assign(:customer_service, [+ Spree::PermissionSets::OrderDisplay,+ Spree::PermissionSets::UserDisplay+ ])++ expect(Spree.permissions.permission_sets_for(:customer_service)).to include(+ Spree::PermissionSets::OrderDisplay,+ Spree::PermissionSets::UserDisplay+ )+ end++ it 'allows clearing permissions from a role' do+ Spree.permissions.assign(:customer_service, Spree::PermissionSets::OrderDisplay)+ Spree.permissions.clear(:customer_service)++ expect(Spree.permissions.permission_sets_for(:customer_service)).to be_empty+ end+ end+enddiff --git a/core/spec/models/spree/permission_sets/base_spec.rb b/core/spec/models/spree/permission_sets/base_spec.rbnew file mode 100644index 0000000000..b25c9f9050--- /dev/null+++ b/core/spec/models/spree/permission_sets/base_spec.rb@@ -0,0 +1,73 @@+require 'spec_helper'+require 'cancan/matchers'++RSpec.describe Spree::PermissionSets::Base do+ let(:user) { build(:user) }+ let(:store) { create(:store) }+ let(:ability) { Spree::Ability.new(user, store: store) }++ describe '#initialize' do+ subject(:permission_set) { described_class.new(ability) }++ it 'stores the ability' do+ expect(permission_set.ability).to eq(ability)+ end+ end++ describe '#activate!' do+ subject(:permission_set) { described_class.new(ability) }++ it 'raises NotImplementedError' do+ expect { permission_set.activate! }.to raise_error(NotImplementedError, /must implement #activate!/)+ end+ end++ describe 'delegation methods' do+ let(:permission_set_class) do+ Class.new(described_class) do+ def activate!+ can :read, Spree::Order+ cannot :destroy, Spree::Order+ end++ def test_can?+ can?(:read, Spree::Order)+ end+ end+ end++ subject(:permission_set) { permission_set_class.new(ability) }++ before { permission_set.activate! }++ describe '#can' do+ it 'delegates to ability' do+ expect(ability.can?(:read, Spree::Order)).to be true+ end+ end++ describe '#cannot' do+ it 'delegates to ability' do+ expect(ability.can?(:destroy, Spree::Order)).to be false+ end+ end++ describe '#can?' do+ it 'delegates to ability' do+ expect(permission_set.test_can?).to be true+ end+ end++ describe '#user' do+ it 'returns the user from the ability' do+ expect(permission_set.send(:user)).to eq(user)+ end+ end++ describe '#store' do+ it 'returns the store from the ability' do+ expect(permission_set.send(:store)).to eq(store)+ end+ end+ end+enddiff --git a/core/spec/models/spree/permission_sets/default_customer_spec.rb b/core/spec/models/spree/permission_sets/default_customer_spec.rbnew file mode 100644index 0000000000..7fd5945459--- /dev/null+++ b/core/spec/models/spree/permission_sets/default_customer_spec.rb@@ -0,0 +1,173 @@+require 'spec_helper'+require 'cancan/matchers'++RSpec.describe Spree::PermissionSets::DefaultCustomer do+ let(:user) { create(:user) }+ let(:ability) { Spree::Ability.new(user) }++ subject(:permission_set) { described_class.new(ability) }++ before { permission_set.activate! }++ describe '#activate!' do+ context 'catalog read access' do+ it 'grants read access to Country' do+ expect(ability.can?(:read, Spree::Country)).to be true+ end++ it 'grants read access to Product' do+ expect(ability.can?(:read, Spree::Product)).to be true+ end++ it 'grants read access to Variant' do+ expect(ability.can?(:read, Spree::Variant)).to be true+ end++ it 'grants read access to Taxon' do+ expect(ability.can?(:read, Spree::Taxon)).to be true+ end++ it 'grants read access to Store' do+ expect(ability.can?(:read, Spree::Store)).to be true+ end+ end++ context 'order permissions' do+ it 'allows creating orders' do+ expect(ability.can?(:create, Spree::Order)).to be true+ end++ context 'with user order' do+ let(:order) { build(:order, user: user) }++ it 'allows viewing own order' do+ expect(ability.can?(:show, order)).to be true+ end++ it 'allows updating own incomplete order' do+ allow(order).to receive(:completed?).and_return(false)+ expect(ability.can?(:update, order)).to be true+ end++ it 'prevents updating own completed order' do+ allow(order).to receive(:completed?).and_return(true)+ expect(ability.can?(:update, order)).to be false+ end+ end++ context 'with token' do+ let(:order) { build(:order, user: nil, token: 'secret') }++ it 'allows viewing order with correct token' do+ expect(ability.can?(:show, order, 'secret')).to be true+ end++ it 'allows updating incomplete order with correct token' do+ allow(order).to receive(:completed?).and_return(false)+ expect(ability.can?(:update, order, 'secret')).to be true+ end++ it 'prevents viewing order with incorrect token' do+ expect(ability.can?(:show, order, 'wrong')).to be false+ end+ end+ end++ context 'user account permissions' do+ it 'allows viewing own user' do+ expect(ability.can?(:show, user)).to be true+ end++ it 'allows updating own user' do+ expect(ability.can?(:update, user)).to be true+ end++ it 'allows destroying own user' do+ expect(ability.can?(:destroy, user)).to be true+ end++ it 'prevents viewing other user' do+ other_user = create(:user)+ expect(ability.can?(:show, other_user)).to be false+ end++ it 'allows creating new user' do+ expect(ability.can?(:create, Spree.user_class)).to be true+ end+ end++ context 'with non-persisted user' do+ let(:guest_user) { build(:user) }+ let(:guest_ability) { Spree::Ability.new(guest_user) }+ let(:guest_permission_set) { described_class.new(guest_ability) }++ before { guest_permission_set.activate! }++ it 'allows viewing self' do+ expect(guest_ability.can?(:show, guest_user)).to be true+ end++ it 'allows updating self' do+ expect(guest_ability.can?(:update, guest_user)).to be true+ end+ end++ context 'address permissions' do+ let(:own_address) { build(:address, user_id: user.id) }+ let(:other_address) { build(:address, user_id: create(:user).id) }++ it 'allows managing own address' do+ expect(ability.can?(:manage, own_address)).to be true+ end++ it 'prevents managing other user address' do+ expect(ability.can?(:manage, other_address)).to be false+ end+ end++ context 'credit card permissions' do+ let(:own_card) { build(:credit_card, user_id: user.id) }+ let(:other_card) { build(:credit_card, user_id: create(:user).id) }++ it 'allows reading own credit card' do+ expect(ability.can?(:read, own_card)).to be true+ end++ it 'allows destroying own credit card' do+ expect(ability.can?(:destroy, own_card)).to be true+ end++ it 'prevents reading other user credit card' do+ expect(ability.can?(:read, other_card)).to be false+ end+ end++ context 'wishlist permissions' do+ let(:own_wishlist) { build(:wishlist, user: user) }+ let(:public_wishlist) { build(:wishlist, user: create(:user), is_private: false) }+ let(:private_wishlist) { build(:wishlist, user: create(:user), is_private: true) }++ it 'allows managing own wishlist' do+ expect(ability.can?(:manage, own_wishlist)).to be true+ end++ it 'allows viewing public wishlist' do+ expect(ability.can?(:show, public_wishlist)).to be true+ end++ it 'prevents viewing private wishlist' do+ expect(ability.can?(:show, private_wishlist)).to be false+ end+ end++ context 'admin permissions' do+ it 'does not grant admin access' do+ expect(ability.can?(:admin, :all)).to be false+ end++ it 'does not grant manage access to Product' do+ expect(ability.can?(:manage, Spree::Product)).to be false+ end+ end+ end+enddiff --git a/core/spec/models/spree/permission_sets/order_management_spec.rb b/core/spec/models/spree/permission_sets/order_management_spec.rbnew file mode 100644index 0000000000..0c99650ae3--- /dev/null+++ b/core/spec/models/spree/permission_sets/order_management_spec.rb@@ -0,0 +1,83 @@+require 'spec_helper'+require 'cancan/matchers'++RSpec.describe Spree::PermissionSets::OrderManagement do+ let(:user) { build(:user) }+ let(:ability) { Spree::Ability.new(user) }++ subject(:permission_set) { described_class.new(ability) }++ before { permission_set.activate! }++ describe '#activate!' do+ it 'grants manage access to Order' do+ expect(ability.can?(:manage, Spree::Order)).to be true+ end++ it 'grants manage access to Payment' do+ expect(ability.can?(:manage, Spree::Payment)).to be true+ end++ it 'grants manage access to Shipment' do+ expect(ability.can?(:manage, Spree::Shipment)).to be true+ end++ it 'grants manage access to Adjustment' do+ expect(ability.can?(:manage, Spree::Adjustment)).to be true+ end++ it 'grants manage access to LineItem' do+ expect(ability.can?(:manage, Spree::LineItem)).to be true+ end++ it 'grants manage access to ReturnAuthorization' do+ expect(ability.can?(:manage, Spree::ReturnAuthorization)).to be true+ end++ it 'grants manage access to CustomerReturn' do+ expect(ability.can?(:manage, Spree::CustomerReturn)).to be true+ end++ it 'grants manage access to Reimbursement' do+ expect(ability.can?(:manage, Spree::Reimbursement)).to be true+ end++ it 'grants manage access to Refund' do+ expect(ability.can?(:manage, Spree::Refund)).to be true+ end++ it 'does not grant manage access to Product' do+ expect(ability.can?(:manage, Spree::Product)).to be false+ end++ context 'order restrictions' do+ let(:cancelable_order) { build(:order) }+ let(:non_cancelable_order) { build(:order) }+ let(:deletable_order) { build(:order) }+ let(:non_deletable_order) { build(:order) }++ before do+ allow(cancelable_order).to receive(:allow_cancel?).and_return(true)+ allow(non_cancelable_order).to receive(:allow_cancel?).and_return(false)+ allow(deletable_order).to receive(:can_be_deleted?).and_return(true)+ allow(non_deletable_order).to receive(:can_be_deleted?).and_return(false)+ end++ it 'allows canceling orders that allow cancellation' do+ expect(ability.can?(:cancel, cancelable_order)).to be true+ end++ it 'prevents canceling orders that do not allow cancellation' do+ expect(ability.can?(:cancel, non_cancelable_order)).to be false+ end++ it 'allows destroying orders that can be deleted' do+ expect(ability.can?(:destroy, deletable_order)).to be true+ end++ it 'prevents destroying orders that cannot be deleted' do+ expect(ability.can?(:destroy, non_deletable_order)).to be false+ end+ end+ end+enddiff --git a/core/spec/models/spree/permission_sets/product_management_spec.rb b/core/spec/models/spree/permission_sets/product_management_spec.rbnew file mode 100644index 0000000000..d14cca746f--- /dev/null+++ b/core/spec/models/spree/permission_sets/product_management_spec.rb@@ -0,0 +1,61 @@+require 'spec_helper'+require 'cancan/matchers'++RSpec.describe Spree::PermissionSets::ProductManagement do+ let(:user) { build(:user) }+ let(:ability) { Spree::Ability.new(user) }++ subject(:permission_set) { described_class.new(ability) }++ before { permission_set.activate! }++ describe '#activate!' do+ it 'grants manage access to Product' do+ expect(ability.can?(:manage, Spree::Product)).to be true+ end++ it 'grants manage access to Variant' do+ expect(ability.can?(:manage, Spree::Variant)).to be true+ end++ it 'grants manage access to OptionType' do+ expect(ability.can?(:manage, Spree::OptionType)).to be true+ end++ it 'grants manage access to OptionValue' do+ expect(ability.can?(:manage, Spree::OptionValue)).to be true+ end++ it 'grants manage access to Property' do+ expect(ability.can?(:manage, Spree::Property)).to be true+ end++ it 'grants manage access to ProductProperty' do+ expect(ability.can?(:manage, Spree::ProductProperty)).to be true+ end++ it 'grants manage access to Taxon' do+ expect(ability.can?(:manage, Spree::Taxon)).to be true+ end++ it 'grants manage access to Taxonomy' do+ expect(ability.can?(:manage, Spree::Taxonomy)).to be true+ end++ it 'grants manage access to Classification' do+ expect(ability.can?(:manage, Spree::Classification)).to be true+ end++ it 'grants manage access to Price' do+ expect(ability.can?(:manage, Spree::Price)).to be true+ end++ it 'does not grant manage access to Order' do+ expect(ability.can?(:manage, Spree::Order)).to be false+ end++ it 'does not grant manage access to User' do+ expect(ability.can?(:manage, Spree.user_class)).to be false+ end+ end+enddiff --git a/core/spec/models/spree/permission_sets/super_user_spec.rb b/core/spec/models/spree/permission_sets/super_user_spec.rbnew file mode 100644index 0000000000..6fc1fb3a4c--- /dev/null+++ b/core/spec/models/spree/permission_sets/super_user_spec.rb@@ -0,0 +1,89 @@+require 'spec_helper'+require 'cancan/matchers'++RSpec.describe Spree::PermissionSets::SuperUser do+ let(:user) { build(:user) }+ let(:ability) { Spree::Ability.new(user) }++ subject(:permission_set) { described_class.new(ability) }++ before { permission_set.activate! }++ describe '#activate!' do+ it 'grants manage access to all resources' do+ expect(ability.can?(:manage, :all)).to be true+ end++ it 'grants manage access to Order' do+ expect(ability.can?(:manage, Spree::Order)).to be true+ end++ it 'grants manage access to Product' do+ expect(ability.can?(:manage, Spree::Product)).to be true+ end++ context 'order restrictions' do+ let(:cancelable_order) { build(:order) }+ let(:non_cancelable_order) { build(:order) }+ let(:deletable_order) { build(:order) }+ let(:non_deletable_order) { build(:order) }++ before do+ allow(cancelable_order).to receive(:allow_cancel?).and_return(true)+ allow(non_cancelable_order).to receive(:allow_cancel?).and_return(false)+ allow(deletable_order).to receive(:can_be_deleted?).and_return(true)+ allow(non_deletable_order).to receive(:can_be_deleted?).and_return(false)+ end++ it 'allows canceling orders that allow cancellation' do+ expect(ability.can?(:cancel, cancelable_order)).to be true+ end++ it 'prevents canceling orders that do not allow cancellation' do+ expect(ability.can?(:cancel, non_cancelable_order)).to be false+ end++ it 'allows destroying orders that can be deleted' do+ expect(ability.can?(:destroy, deletable_order)).to be true+ end++ it 'prevents destroying orders that cannot be deleted' do+ expect(ability.can?(:destroy, non_deletable_order)).to be false+ end+ end++ context 'immutable types' do+ let(:mutable_refund_reason) { build(:refund_reason, mutable: true) }+ let(:immutable_refund_reason) { build(:refund_reason, mutable: false) }++ it 'allows editing mutable refund reasons' do+ expect(ability.can?(:edit, mutable_refund_reason)).to be true+ end++ it 'prevents editing immutable refund reasons' do+ expect(ability.can?(:edit, immutable_refund_reason)).to be false+ end+ end++ context 'admin role protection' do+ let(:admin_role) { build(:role, name: 'admin') }+ let(:other_role) { build(:role, name: 'customer_service') }++ it 'prevents updating the admin role' do+ expect(ability.can?(:update, admin_role)).to be false+ end++ it 'prevents destroying the admin role' do+ expect(ability.can?(:destroy, admin_role)).to be false+ end++ it 'allows updating other roles' do+ expect(ability.can?(:update, other_role)).to be true+ end++ it 'allows destroying other roles' do+ expect(ability.can?(:destroy, other_role)).to be true+ end+ end+ end+end