spree_core 5.2.6 → 5.3.0.rc1

data/lib/spree/events.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require_relative 'events/registry'
+require_relative 'events/adapters/base'
+require_relative 'events/adapters/active_support_notifications'
+
+module Spree
+  # Main entry point for the Spree event system.
+  #
+  # This module provides a clean API for publishing events and subscribing
+  # to them. It abstracts the underlying implementation (ActiveSupport::Notifications)
+  # allowing for future changes without affecting subscriber code.
+  #
+  # @example Publishing an event
+  #   Spree::Events.publish('order.completed', order.serializable_hash)
+  #
+  # @example Subscribing with a class
+  #   Spree::Events.subscribe('order.completed', OrderCompletedHandler)
+  #
+  # @example Subscribing with a block
+  #   Spree::Events.subscribe('order.completed') do |event|
+  #     puts "Order completed: #{event.payload['number']}"
+  #   end
+  #
+  # @example Pattern matching
+  #   Spree::Events.subscribe('order.*', OrderAuditLogger)  # All order events
+  #   Spree::Events.subscribe('*', GlobalEventLogger)       # All events
+  #
+  module Events
+    class << self
+      # Publish an event to all matching subscribers
+      #
+      # @param name [String] The event name (e.g., 'order.complete')
+      # @param payload [Hash] The event payload (should be serializable)
+      # @param metadata [Hash] Additional metadata for the event
+      # @return [Spree::Event] The published event
+      #
+      # @example
+      #   Spree::Events.publish('product.created', product.serializable_hash)
+      #   Spree::Events.publish('order.completed', order.serializable_hash, { user_id: current_user.id })
+      #
+      def publish(name, payload = {}, metadata = {})
+        adapter.publish(name, payload, metadata)
+      end
+
+      # Subscribe to an event pattern
+      #
+      # @param pattern [String] Event pattern (supports wildcards like 'order.*' or '*')
+      # @param subscriber [Class, Proc, nil] The subscriber class or callable
+      # @param options [Hash] Subscription options
+      # @option options [Boolean] :async (true) Whether to run async via ActiveJob
+      # @yield [event] Block to execute when event occurs (alternative to subscriber param)
+      # @yieldparam event [Spree::Event] The event object
+      # @return [void]
+      #
+      # @example With a subscriber class
+      #   Spree::Events.subscribe('order.completed', SendConfirmationEmail)
+      #
+      # @example With a block
+      #   Spree::Events.subscribe('order.completed') { |event| puts event.name }
+      #
+      # @example With pattern matching
+      #   Spree::Events.subscribe('order.*', OrderAuditLogger)
+      #
+      # @example Synchronous execution
+      #   Spree::Events.subscribe('order.completed', MyHandler, async: false)
+      #
+      def subscribe(pattern, subscriber = nil, options = {}, &block)
+        subscriber = block if block_given?
+        raise ArgumentError, 'Must provide a subscriber class, callable, or block' unless subscriber
+
+        adapter.subscribe(pattern, subscriber, options)
+      end
+
+      # Unsubscribe from an event pattern
+      #
+      # @param pattern [String] Event pattern
+      # @param subscriber [Class, Proc] The subscriber to remove
+      # @return [Boolean] true if removed, false if not found
+      def unsubscribe(pattern, subscriber)
+        adapter.unsubscribe(pattern, subscriber)
+      end
+
+      # Get the event registry
+      #
+      # @return [Spree::Events::Registry]
+      def registry
+        @registry ||= Registry.new
+      end
+
+      # Get the adapter instance
+      #
+      # The adapter class can be configured via Spree.events_adapter_class
+      # Default: Spree::Events::Adapters::ActiveSupportNotifications
+      #
+      # @return [Object] the configured adapter instance
+      def adapter
+        @adapter ||= Spree.events_adapter_class.new(registry)
+      end
+
+      # Activate the event system (called during Rails initialization)
+      # Also registers all subscribers from Spree.subscribers
+      # This method is idempotent - calling it multiple times has no effect
+      def activate!
+        return if registry.size > 0
+
+        register_subscribers!
+        adapter.activate!
+      end
+
+      # Reset the event system (useful for testing)
+      def reset!
+        adapter.deactivate! if @adapter
+        @registry = nil
+        @adapter = nil
+      end
+
+      # Register all subscribers from Spree.subscribers
+      #
+      # This is called automatically during Rails initialization.
+      # Can also be called in tests after reset! to re-register subscribers.
+      #
+      # In development, class objects in Spree.subscribers may become stale after
+      # code reload (Zeitwerk creates new class objects). We resolve the constant
+      # fresh from the class name to ensure we're using the reloaded class.
+      #
+      # @return [void]
+      def register_subscribers!
+        return unless defined?(Spree) && Spree.respond_to?(:subscribers)
+
+        Spree.subscribers&.each do |subscriber|
+          # Resolve the subscriber constant fresh to handle code reload in development
+          # The array may contain stale class objects after Zeitwerk reload
+          resolved_subscriber = resolve_subscriber(subscriber)
+          next unless resolved_subscriber
+
+          resolved_subscriber.subscription_patterns.each do |pattern|
+            subscribe(pattern, resolved_subscriber, resolved_subscriber.subscription_options)
+          end
+        end
+      end
+
+      # Resolve a subscriber to its current class object
+      #
+      # In development, Zeitwerk may have reloaded the class, creating a new
+      # class object while the old one is still referenced in Spree.subscribers.
+      # This method resolves the constant fresh to get the current class.
+      #
+      # @param subscriber [Class, String] The subscriber class or class name
+      # @return [Class, nil] The resolved class or nil if not found
+      def resolve_subscriber(subscriber)
+        return subscriber unless Rails.env.development? || Rails.env.test?
+
+        class_name = subscriber.is_a?(String) ? subscriber : subscriber.name
+        return nil unless class_name
+
+        class_name.constantize
+      rescue NameError => e
+        Rails.logger.warn "[Spree Events] Could not resolve subscriber #{class_name}: #{e.message}"
+        nil
+      end
+
+      # List all registered subscriber patterns
+      #
+      # @return [Array<String>]
+      def patterns
+        registry.patterns
+      end
+
+      # List all subscriptions
+      #
+      # @return [Array<Spree::Events::Registry::Subscription>]
+      def subscriptions
+        registry.all_subscriptions
+      end
+
+      # Check if events are enabled
+      #
+      # Events can be temporarily disabled using Spree::Events.disable { ... }
+      #
+      # @return [Boolean]
+      def enabled?
+        !RequestStore.store[:spree_events_disabled]
+      end
+
+      # Temporarily disable events within a block
+      #
+      # @yield Block during which events are disabled
+      # @return [Object] Return value of the block
+      #
+      # @example
+      #   Spree::Events.disable do
+      #     # Events published here won't trigger subscribers
+      #     order.complete!
+      #   end
+      #
+      def disable
+        previous = RequestStore.store[:spree_events_disabled]
+        RequestStore.store[:spree_events_disabled] = true
+        yield
+      ensure
+        RequestStore.store[:spree_events_disabled] = previous
+      end
+
+      # Globally disable events
+      # Useful for testing to disable events for the entire test suite
+      # @return [void]
+      def disable!
+        RequestStore.store[:spree_events_disabled] = true
+      end
+
+      # Temporarily enable events within a block
+      # Useful for testing when events are globally disabled
+      #
+      # @yield Block during which events are enabled
+      # @return [Object] Return value of the block
+      #
+      # @example
+      #   Spree::Events.enable do
+      #     # Events published here will trigger subscribers
+      #     order.complete!
+      #   end
+      #
+      def enable
+        previous = RequestStore.store[:spree_events_disabled]
+        RequestStore.store[:spree_events_disabled] = false
+        yield
+      ensure
+        RequestStore.store[:spree_events_disabled] = previous
+      end
+
+      # Globally enable events
+      # Useful for testing
+      # @return [void]
+      def enable!
+        RequestStore.store[:spree_events_disabled] = false
+      end
+    end
+  end
+end

data/lib/spree/permitted_attributes.rb

@@ -8,6 +8,7 @@ module Spree
       :cms_page_attributes,
       :cms_section_attributes,
       :custom_domain_attributes,
+      :customer_group_attributes,
       :customer_return_attributes,
       :digital_attributes,
       :digital_link_attributes,
@@ -36,6 +37,7 @@ module Spree
       :policy_attributes,
       :post_attributes,
       :post_category_attributes,
+      :price_list_attributes,
       :product_attributes,
       :promotion_attributes,
       :promotion_rule_attributes,
@@ -68,6 +70,7 @@ module Spree
       :theme_attributes,
       :user_attributes,
       :variant_attributes,
+      :webhook_endpoint_attributes,
       :wishlist_attributes,
       :wished_item_attributes,
       :zone_attributes
@@ -88,7 +91,8 @@ module Spree
 
     @@checkout_attributes = [
       :coupon_code, :email, :shipping_method_id, :special_instructions, :use_billing, :use_shipping,
-      :user_id, :bill_address_id, :ship_address_id, :accept_marketing, :signup_for_an_account, :currency
+      :user_id, :bill_address_id, :ship_address_id, :accept_marketing, :signup_for_an_account, :currency,
+      :internal_note
     ]
 
     @@classification_attributes = [
@@ -101,6 +105,8 @@ module Spree
 
     @@custom_domain_attributes = [:url, :default]
 
+    @@customer_group_attributes = [:name, :description]
+
     @@customer_return_attributes = [:stock_location_id, {
       return_items_attributes: [:id, :inventory_unit_id, :return_authorization_id, :returned, :pre_tax_amount,
                                 :acceptance_status, :exchange_variant_id, :resellable]
@@ -162,6 +168,8 @@ module Spree
 
     @@post_category_attributes = [:title, :slug, :description]
 
+    @@price_list_attributes = [:name, :description, :match_policy, :starts_at, :ends_at, :status, :position]
+
     @@product_properties_attributes = [:property_name, :property_id, :value, :position, :_destroy]
 
     @@product_attributes = [
@@ -290,7 +298,8 @@ module Spree
 
     @@user_attributes = [:email, :bill_address_id, :ship_address_id, :password, :first_name, :last_name,
                          :password_confirmation, :selected_locale, :avatar, :accepts_email_marketing, :phone,
-                         { public_metadata: {}, private_metadata: {}, tag_list: [] }]
+                         :internal_note,
+                         { public_metadata: {}, private_metadata: {}, tag_list: [], customer_group_ids: [] }]
 
     @@variant_attributes = [
       :name, :presentation, :cost_price, :discontinue_on, :lock_version,
@@ -308,6 +317,8 @@ module Spree
       }
     ]
 
+    @@webhook_endpoint_attributes = [:url, :secret, :active, subscriptions: []]
+
     @@wishlist_attributes = [:name, :is_default, :is_private]
 
     @@wished_item_attributes = [:variant_id, :quantity]

data/lib/spree/testing_support/common_rake.rb

@@ -1,7 +1,3 @@
-unless defined?(Spree::InstallGenerator)
-  require 'generators/spree/install/install_generator'
-end
-
 require 'generators/spree/dummy/dummy_generator'
 require 'generators/spree/dummy_model/dummy_model_generator'
 
@@ -9,56 +5,85 @@ desc 'Generates a dummy app for testing'
 namespace :common do
   task :test_app, :user_class do |_t, args|
     args.with_defaults(
+      authentication: 'dummy',
       user_class: 'Spree::LegacyUser',
-      install_storefront: 'false',
-      install_admin: 'false',
-      authentication: 'dummy'
+      install_storefront: false,
+      install_admin: false,
+      javascript: false,
+      css: false
     )
     require ENV['LIB_NAME'].to_s
 
+    # Convert to booleans (supports both string and boolean values for backwards compatibility)
+    install_admin = args[:install_admin].to_b
+    install_storefront = args[:install_storefront].to_b
+    javascript_enabled = args[:javascript].to_b
+    css_enabled = args[:css].to_b
+
+    # Admin and Storefront require JavaScript and CSS (Tailwind) to function properly
+    javascript_enabled ||= install_admin || install_storefront
+    css_enabled ||= install_admin || install_storefront
+
+    puts args
+
     ENV['RAILS_ENV'] = 'test'
     Rails.env = 'test'
 
-    api_only = ['spree/api', 'spree/core', 'spree/sample'].include?(ENV['LIB_NAME'])
-    skip_javascript = api_only || ENV['LIB_NAME'] == 'spree/emails'
-
     dummy_app_args = [
       "--lib_name=#{ENV['LIB_NAME']}"
     ]
-    if api_only
-      dummy_app_args << '--api'
-    elsif skip_javascript
-      dummy_app_args << '--skip_javascript'
-    end
+    # Use API mode only if no frontend components are needed
+    use_api_mode = !install_storefront && !install_admin && !javascript_enabled && !css_enabled
+    dummy_app_args << '--api' if use_api_mode
+    dummy_app_args << '--javascript' if javascript_enabled
+    dummy_app_args << '--css=tailwind' if css_enabled
+
+    puts dummy_app_args
+
     Spree::DummyGenerator.start dummy_app_args
 
-    unless skip_javascript
-      system('bundle add sprockets-rails') # we need this until we will remove bootstrap/popper_js gems
-      system('bundle exec rails importmap:install turbo:install stimulus:install')
+    # Install JavaScript dependencies (importmap, turbo, stimulus) if JavaScript is enabled
+    # Rails includes the gems but doesn't run the installers automatically
+    if javascript_enabled
+      puts 'Installing JavaScript dependencies...'
+      system('yes | bundle exec rails importmap:install turbo:install stimulus:install')
     end
 
     # install devise if it's not the legacy user, useful for testing storefront
     if args[:authentication] == 'devise' && args[:user_class] != 'Spree::LegacyUser'
       system('bundle exec rails g devise:install --force --auto-accept')
       system("bundle exec rails g devise #{args[:user_class]} --force --auto-accept")
+      system("bundle exec rails g devise #{args[:admin_user_class]} --force --auto-accept") if args[:admin_user_class].present? && args[:admin_user_class] != args[:user_class]
       system('rm -rf spec') # we need to cleanup factories created by devise to avoid naming conflict
     end
 
-    Spree::InstallGenerator.start [
-      "--lib_name=#{ENV['LIB_NAME']}",
-      '--auto-accept',
-      '--migrate=false',
-      '--seed=false',
-      '--sample=false',
-      "--install_storefront=#{args[:install_storefront]}",
-      "--install_admin=#{args[:install_admin]}",
-      "--user_class=#{args[:user_class]}",
-      "--authentication=#{args[:authentication]}"
-    ]
+    # Run core Spree install generator
+    puts 'Running Spree install generator...'
+    system("bundle exec rails g spree:install --force --auto-accept --migrate=false --seed=false --sample=false --user_class=#{args[:user_class]} --admin_user_class=#{args[:admin_user_class]} --authentication=#{args[:authentication]}")
 
-    if !skip_javascript || ENV['LIB_NAME'] == 'spree/emails'
-      puts 'Precompiling assets...'
-      system('bundle exec rake assets:precompile > /dev/null 2>&1')
+    # Determine if we need to install admin/storefront
+    # Either via explicit flag or because we're testing that gem itself
+    needs_admin = install_admin || ENV['LIB_NAME'] == 'spree/admin'
+    needs_storefront = install_storefront || ENV['LIB_NAME'] == 'spree/storefront'
+
+    # Run admin install generator if requested or testing admin gem
+    if needs_admin
+      # Only run install if explicitly requested (not when testing admin gem itself)
+      if install_admin
+        puts 'Running Spree Admin install generator...'
+        system('bundle exec rails g spree:admin:install --force')
+      end
+      system('bundle exec rails g spree:admin:devise --force') if args[:authentication] == 'devise'
+    end
+
+    # Run storefront install generator if requested or testing storefront gem
+    if needs_storefront
+      # Only run install if explicitly requested (not when testing storefront gem itself)
+      if install_storefront
+        puts 'Running Spree Storefront install generator...'
+        system('bundle exec rails g spree:storefront:install --force --migrate=false')
+      end
+      system('bundle exec rails g spree:storefront:devise --force') if args[:authentication] == 'devise'
     end
 
     unless ENV['NO_MIGRATE']
@@ -74,13 +99,21 @@ namespace :common do
       puts 'Running extension installation generator...'
 
       if ENV['NO_MIGRATE']
-        "#{ENV['LIB_NAME'].camelize}::Generators::InstallGenerator".constantize.start([])
+        "#{ENV['LIB_NAME'].camelize}::Generators::InstallGenerator".constantize.start(['--force'])
       else
-        "#{ENV['LIB_NAME'].camelize}::Generators::InstallGenerator".constantize.start(['--auto-run-migrations'])
+        "#{ENV['LIB_NAME'].camelize}::Generators::InstallGenerator".constantize.start(['--force', '--auto-run-migrations'])
       end
-    rescue LoadError
+    rescue LoadError => e
+      puts "Error loading generator: #{e.message}"
       puts 'Skipping installation no generator to run...'
     end
+
+    # Precompile assets after all generators have run
+    # This ensures CSS entry points (like Spree Admin's Tailwind CSS) are created first
+    if javascript_enabled || css_enabled
+      puts 'Precompiling assets...'
+      system('bundle exec rake assets:precompile')
+    end
   end
 
   task :db_setup do |_t|

data/lib/spree/testing_support/factories/customer_group_factory.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :customer_group, class: Spree::CustomerGroup do
+    sequence(:name) { |n| "Customer Group #{n}" }
+    store { Spree::Store.default || create(:store) }
+  end
+end

data/lib/spree/testing_support/factories/customer_group_user_factory.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :customer_group_user, class: Spree::CustomerGroupUser do
+    customer_group
+    user { create(:user) }
+  end
+end

data/lib/spree/testing_support/factories/price_factory.rb

@@ -3,5 +3,9 @@ FactoryBot.define do
     variant
     amount   { 19.99 }
     currency { 'USD' }
+
+    factory :price_eur do
+      currency { 'EUR' }
+    end
   end
 end

data/lib/spree/testing_support/factories/price_list_factory.rb

@@ -0,0 +1,34 @@
+FactoryBot.define do
+  factory :price_list, class: Spree::PriceList do
+    sequence(:name) { |n| "Price List #{n}" }
+    store { Spree::Store.default || create(:store) }
+    match_policy { 'all' }
+
+    trait :draft do
+      status { 'draft' }
+    end
+
+    trait :active do
+      status { 'active' }
+    end
+
+    trait :inactive do
+      status { 'inactive' }
+    end
+
+    trait :scheduled do
+      status { 'scheduled' }
+      starts_at { 1.hour.from_now }
+      ends_at { 1.week.from_now }
+    end
+
+    trait :with_date_range do
+      starts_at { 1.day.ago }
+      ends_at { 1.day.from_now }
+    end
+
+    trait :any_match do
+      match_policy { 'any' }
+    end
+  end
+end

data/lib/spree/testing_support/factories/price_rule_factory.rb

@@ -0,0 +1,49 @@
+FactoryBot.define do
+  factory :price_rule, class: Spree::PriceRule do
+    price_list
+
+    factory :zone_price_rule, class: Spree::PriceRules::ZoneRule do
+      after(:build) do |rule, evaluator|
+        rule.preferred_zone_ids = evaluator.zone_ids if evaluator.respond_to?(:zone_ids)
+      end
+
+      transient do
+        zone_ids { [] }
+      end
+    end
+
+    factory :volume_price_rule, class: Spree::PriceRules::VolumeRule do
+      after(:build) do |rule, evaluator|
+        rule.preferred_min_quantity = evaluator.min_quantity if evaluator.min_quantity.present?
+        rule.preferred_max_quantity = evaluator.max_quantity if evaluator.max_quantity.present?
+        rule.preferred_apply_to = evaluator.apply_to if evaluator.apply_to.present?
+      end
+
+      transient do
+        min_quantity { nil }
+        max_quantity { nil }
+        apply_to { nil }
+      end
+    end
+
+    factory :user_price_rule, class: Spree::PriceRules::UserRule do
+      after(:build) do |rule, evaluator|
+        rule.preferred_user_ids = evaluator.user_ids if evaluator.respond_to?(:user_ids)
+      end
+
+      transient do
+        user_ids { [] }
+      end
+    end
+
+    factory :customer_group_price_rule, class: Spree::PriceRules::CustomerGroupRule do
+      after(:build) do |rule, evaluator|
+        rule.preferred_customer_group_ids = evaluator.customer_group_ids if evaluator.respond_to?(:customer_group_ids)
+      end
+
+      transient do
+        customer_group_ids { [] }
+      end
+    end
+  end
+end

data/lib/spree/testing_support/factories/promotion_rule_factory.rb

@@ -18,4 +18,16 @@ FactoryBot.define do
   factory :promotion_rule_option_value, class: Spree::Promotion::Rules::OptionValue do
     association :promotion
   end
+
+  factory :promotion_rule_customer_group, class: Spree::Promotion::Rules::CustomerGroup do
+    association :promotion
+
+    after(:build) do |rule, evaluator|
+      rule.preferred_customer_group_ids = evaluator.customer_group_ids if evaluator.respond_to?(:customer_group_ids)
+    end
+
+    transient do
+      customer_group_ids { [] }
+    end
+  end
 end

data/lib/spree/testing_support/factories/stock_item_factory.rb

@@ -5,10 +5,12 @@ FactoryBot.define do
     variant
 
     before(:create) do |stock_item|
-      Spree::StockItem.find_by(
-        variant: stock_item.variant,
-        stock_location: stock_item.stock_location
-      )&.destroy
+      # Use really_destroy! (hard delete) to avoid unique index conflicts
+      # with deleted_at timestamps in MySQL when tests run quickly
+      Spree::StockItem.where(
+        variant_id: stock_item.variant_id,
+        stock_location_id: stock_item.stock_location_id
+      ).delete_all
     end
 
     transient do

data/lib/spree/testing_support/factories/store_product_factory.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :store_product, class: Spree::StoreProduct do
+    store
+    product
+  end
+end

data/lib/spree/testing_support/factories/taxon_factory.rb

@@ -3,7 +3,6 @@ FactoryBot.define do
     sequence(:name) { |n| "taxon_#{n}" }
 
     association :taxonomy, strategy: :create
-    association :icon, factory: :taxon_image
     parent_id { taxonomy.root.id }
 
     trait :with_description do

data/lib/spree/testing_support/factories/webhook_delivery_factory.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :webhook_delivery, class: Spree::WebhookDelivery do
+    webhook_endpoint
+    event_name { 'order.created' }
+    payload { { event: 'order.created', data: { id: 1 } } }
+
+    trait :pending do
+      response_code { nil }
+      execution_time { nil }
+      success { nil }
+      delivered_at { nil }
+    end
+
+    trait :successful do
+      response_code { 200 }
+      execution_time { 150 }
+      success { true }
+      delivered_at { Time.current }
+    end
+
+    trait :failed do
+      response_code { 500 }
+      execution_time { 200 }
+      success { false }
+      delivered_at { Time.current }
+    end
+
+    trait :timeout do
+      response_code { nil }
+      error_type { 'timeout' }
+      execution_time { 30_000 }
+      success { false }
+      request_errors { 'execution expired' }
+      delivered_at { Time.current }
+    end
+
+    trait :connection_error do
+      response_code { nil }
+      error_type { 'connection_error' }
+      execution_time { 100 }
+      success { false }
+      request_errors { 'Connection refused' }
+      delivered_at { Time.current }
+    end
+  end
+end