Merge pull request #6292 from mamhoff/move-load-promotions-out-of-order-adjuster

Move LoadPromotions out of OrderAdjuster namespace

Author: tvdeyen

promotions/app/models/solidus_promotions/load_promotions.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class LoadPromotions
+    def initialize(order:, dry_run_promotion: nil)
+      @order = order
+      @dry_run_promotion = dry_run_promotion
+    end
+
+    def call
+      promos = connected_order_promotions | sale_promotions
+      promos << dry_run_promotion if dry_run_promotion
+      promos.flat_map(&:benefits).group_by(&:preload_relations).each do |benefit_preload_relations, benefits|
+        preload(records: benefits, associations: benefit_preload_relations)
+        benefits.flat_map(&:conditions).group_by(&:preload_relations).each do |condition_preload_relations, conditions|
+          preload(records: conditions, associations: condition_preload_relations)
+        end
+      end
+      promos.reject { |promotion| promotion.usage_limit_exceeded?(excluded_orders: [order]) }
+    end
+
+    private
+
+    attr_reader :order, :dry_run_promotion
+
+    def preload(records:, associations:)
+      ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+    end
+
+    def connected_order_promotions
+      eligible_connected_promotion_ids = order.solidus_order_promotions.select do |order_promotion|
+        order_promotion.promotion.kept? && (order_promotion.promotion_code.nil? || !order_promotion.promotion_code.usage_limit_exceeded?(excluded_orders: [order]))
+      end.map(&:promotion_id)
+      order.solidus_promotions.active(reference_time).where(id: eligible_connected_promotion_ids).includes(promotion_includes)
+    end
+
+    def sale_promotions
+      SolidusPromotions::Promotion.kept.where(apply_automatically: true).active(reference_time).includes(promotion_includes)
+    end
+
+    def reference_time
+      order.completed_at || Time.current
+    end
+
+    def promotion_includes
+      {
+        benefits: :conditions
+      }
+    end
+  end
+end

promotions/app/models/solidus_promotions/order_adjuster.rb

@@ -7,7 +7,10 @@ class OrderAdjuster
     def initialize(order, dry_run_promotion: nil)
       @order = order
       @dry_run = !!dry_run_promotion
-      @promotions = LoadPromotions.new(order: order, dry_run_promotion: dry_run_promotion).call
+      @promotions = SolidusPromotions::LoadPromotions.new(
+        order: order,
+        dry_run_promotion: dry_run_promotion
+      ).call
     end
 
     def call

promotions/app/models/solidus_promotions/order_adjuster/load_promotions.rb

@@ -2,51 +2,10 @@
 
 module SolidusPromotions
   class OrderAdjuster
-    class LoadPromotions
-      def initialize(order:, dry_run_promotion: nil)
-        @order = order
-        @dry_run_promotion = dry_run_promotion
-      end
-
-      def call
-        promos = connected_order_promotions | sale_promotions
-        promos << dry_run_promotion if dry_run_promotion
-        promos.flat_map(&:benefits).group_by(&:preload_relations).each do |benefit_preload_relations, benefits|
-          preload(records: benefits, associations: benefit_preload_relations)
-          benefits.flat_map(&:conditions).group_by(&:preload_relations).each do |condition_preload_relations, conditions|
-            preload(records: conditions, associations: condition_preload_relations)
-          end
-        end
-        promos.reject { |promotion| promotion.usage_limit_exceeded?(excluded_orders: [order]) }
-      end
-
-      private
-
-      attr_reader :order, :dry_run_promotion
-
-      def preload(records:, associations:)
-        ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
-      end
-
-      def connected_order_promotions
-        eligible_connected_promotion_ids = order.solidus_order_promotions.select do |order_promotion|
-          order_promotion.promotion.kept? && (order_promotion.promotion_code.nil? || !order_promotion.promotion_code.usage_limit_exceeded?(excluded_orders: [order]))
-        end.map(&:promotion_id)
-        order.solidus_promotions.active(reference_time).where(id: eligible_connected_promotion_ids).includes(promotion_includes)
-      end
-
-      def sale_promotions
-        SolidusPromotions::Promotion.kept.where(apply_automatically: true).active(reference_time).includes(promotion_includes)
-      end
-
-      def reference_time
-        order.completed_at || Time.current
-      end
-
-      def promotion_includes
-        {
-          benefits: :conditions
-        }
+    class LoadPromotions < SolidusPromotions::LoadPromotions
+      def initialize(...)
+        Spree.deprecator.warn("Please use SolidusPromotions::LoadPromotions instead")
+        super
       end
     end
   end

promotions/spec/models/solidus_promotions/load_promotions_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe SolidusPromotions::LoadPromotions do
+  describe "selecting promotions" do
+    subject { described_class.new(order: order).call }
+
+    let(:order) { create(:order) }
+
+    let!(:active_promotion) { create(:solidus_promotion, :with_adjustable_benefit, apply_automatically: true) }
+    let!(:inactive_promotion) do
+      create(:solidus_promotion, :with_adjustable_benefit, expires_at: 2.days.ago, apply_automatically: true)
+    end
+    let!(:connectable_promotion) { create(:solidus_promotion, :with_adjustable_benefit) }
+    let!(:connectable_inactive_promotion) do
+      create(:solidus_promotion, :with_adjustable_benefit, expires_at: 2.days.ago)
+    end
+
+    context "no promo is connected to the order" do
+      it "returns only active promotions" do
+        expect(subject).to eq([active_promotion])
+      end
+    end
+
+    context "an active promo is connected to the order" do
+      before do
+        order.solidus_promotions << connectable_promotion
+      end
+
+      it "checks active and connected promotions" do
+        expect(subject).to include(active_promotion, connectable_promotion)
+      end
+    end
+
+    context "an inactive promo is connected to the order" do
+      before do
+        order.solidus_promotions << connectable_inactive_promotion
+      end
+
+      it "does not check connected inactive promotions" do
+        expect(subject).not_to include(connectable_inactive_promotion)
+        expect(subject).to eq([active_promotion])
+      end
+    end
+
+    context "discarded promotions" do
+      let!(:discarded_promotion) { create(:solidus_promotion, :with_adjustable_benefit, deleted_at: 1.hour.ago, apply_automatically: true) }
+
+      it "does not check discarded promotions" do
+        expect(subject).not_to include(discarded_promotion)
+      end
+
+      context "a discarded promo is connected to the order" do
+        before do
+          order.solidus_promotions << discarded_promotion
+        end
+
+        it "does not check connected discarded promotions" do
+          expect(subject).not_to include(discarded_promotion)
+          expect(subject).to eq([active_promotion])
+        end
+      end
+    end
+  end
+
+  context "promotions in the past" do
+    let(:order) { create(:order, completed_at: 7.days.ago) }
+    let(:currently_active_promotion) { create(:solidus_promotion, :with_adjustable_benefit, starts_at: 1.hour.ago) }
+    let(:past_promotion) { create(:solidus_promotion, :with_adjustable_benefit, starts_at: 1.year.ago, expires_at: 11.months.ago) }
+    let(:order_promotion) { create(:solidus_promotion, :with_adjustable_benefit, starts_at: 8.days.ago, expires_at: 6.days.ago) }
+
+    before do
+      order.solidus_promotions << past_promotion
+      order.solidus_promotions << order_promotion
+      order.solidus_promotions << currently_active_promotion
+    end
+
+    subject { described_class.new(order: order).call }
+
+    it "only evaluates the past promotion that was active when the order was completed" do
+      expect(subject).to eq([order_promotion])
+    end
+  end
+end

promotions/spec/models/solidus_promotions/order_adjuster/load_promotions_spec.rb

@@ -3,83 +3,12 @@
 require "rails_helper"
 
 RSpec.describe SolidusPromotions::OrderAdjuster::LoadPromotions do
-  describe "selecting promotions" do
-    subject { described_class.new(order: order).call }
+  let(:order) { Spree::Order.new }
 
-    let(:order) { create(:order) }
+  subject { described_class.new(order:) }
 
-    let!(:active_promotion) { create(:solidus_promotion, :with_adjustable_benefit, apply_automatically: true) }
-    let!(:inactive_promotion) do
-      create(:solidus_promotion, :with_adjustable_benefit, expires_at: 2.days.ago, apply_automatically: true)
-    end
-    let!(:connectable_promotion) { create(:solidus_promotion, :with_adjustable_benefit) }
-    let!(:connectable_inactive_promotion) do
-      create(:solidus_promotion, :with_adjustable_benefit, expires_at: 2.days.ago)
-    end
-
-    context "no promo is connected to the order" do
-      it "returns only active promotions" do
-        expect(subject).to eq([active_promotion])
-      end
-    end
-
-    context "an active promo is connected to the order" do
-      before do
-        order.solidus_promotions << connectable_promotion
-      end
-
-      it "checks active and connected promotions" do
-        expect(subject).to include(active_promotion, connectable_promotion)
-      end
-    end
-
-    context "an inactive promo is connected to the order" do
-      before do
-        order.solidus_promotions << connectable_inactive_promotion
-      end
-
-      it "does not check connected inactive promotions" do
-        expect(subject).not_to include(connectable_inactive_promotion)
-        expect(subject).to eq([active_promotion])
-      end
-    end
-
-    context "discarded promotions" do
-      let!(:discarded_promotion) { create(:solidus_promotion, :with_adjustable_benefit, deleted_at: 1.hour.ago, apply_automatically: true) }
-
-      it "does not check discarded promotions" do
-        expect(subject).not_to include(discarded_promotion)
-      end
-
-      context "a discarded promo is connected to the order" do
-        before do
-          order.solidus_promotions << discarded_promotion
-        end
-
-        it "does not check connected discarded promotions" do
-          expect(subject).not_to include(discarded_promotion)
-          expect(subject).to eq([active_promotion])
-        end
-      end
-    end
-  end
-
-  context "promotions in the past" do
-    let(:order) { create(:order, completed_at: 7.days.ago) }
-    let(:currently_active_promotion) { create(:solidus_promotion, :with_adjustable_benefit, starts_at: 1.hour.ago) }
-    let(:past_promotion) { create(:solidus_promotion, :with_adjustable_benefit, starts_at: 1.year.ago, expires_at: 11.months.ago) }
-    let(:order_promotion) { create(:solidus_promotion, :with_adjustable_benefit, starts_at: 8.days.ago, expires_at: 6.days.ago) }
-
-    before do
-      order.solidus_promotions << past_promotion
-      order.solidus_promotions << order_promotion
-      order.solidus_promotions << currently_active_promotion
-    end
-
-    subject { described_class.new(order: order).call }
-
-    it "only evaluates the past promotion that was active when the order was completed" do
-      expect(subject).to eq([order_promotion])
-    end
+  it "tells the user to use SolidusPromotions::LoadPromotions instead" do
+    expect(Spree.deprecator).to receive(:warn).with("Please use SolidusPromotions::LoadPromotions instead")
+    expect(subject).to be_a(SolidusPromotions::LoadPromotions)
   end
 end