solidus_core 2.10.1 → 2.11.2

data/spec/models/spree/promotion/actions/create_adjustment_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Actions::CreateAdjustment, type: :model do
-  let(:order) { create(:order_with_line_items, line_items_count: 1) }
-  let(:promotion) { create(:promotion) }
-  let(:action) { Spree::Promotion::Actions::CreateAdjustment.new }
-  let(:payload) { { order: order } }
-
-  # From promotion spec:
-  context "#perform" do
-    before do
-      action.calculator = Spree::Calculator::FlatRate.new(preferred_amount: 10)
-      promotion.promotion_actions = [action]
-      allow(action).to receive_messages(promotion: promotion)
-    end
-
-    it "does apply an adjustment if the amount is 0" do
-      action.calculator.preferred_amount = 0
-      action.perform(payload)
-      expect(order.adjustments.count).to eq(1)
-    end
-
-    it "should create a discount with correct negative amount" do
-      order.shipments.create!(cost: 10)
-
-      action.perform(payload)
-      expect(promotion.usage_count).to eq(0)
-      expect(order.adjustments.count).to eq(1)
-      expect(order.adjustments.first.amount.to_i).to eq(-10)
-    end
-
-    it "should create a discount accessible through both order_id and adjustable_id" do
-      action.perform(payload)
-      expect(order.adjustments.count).to eq(1)
-      expect(order.all_adjustments.count).to eq(1)
-    end
-
-    it "should not create a discount when order already has one from this promotion" do
-      order.shipments.create!(cost: 10)
-
-      action.perform(payload)
-      action.perform(payload)
-      expect(promotion.usage_count).to eq(0)
-      expect(order.adjustments.count).to eq(1)
-    end
-
-    context "when a promotion code is used" do
-      let(:promotion_code) { create(:promotion_code) }
-      let(:promotion) { promotion_code.promotion }
-      let(:payload) { { order: order, promotion_code: promotion_code } }
-
-      it "should connect the adjustment to the promotion_code" do
-        expect {
-          action.perform(payload)
-        }.to change { order.adjustments.count }.by(1)
-        expect(order.adjustments.last.promotion_code).to eq promotion_code
-      end
-    end
-  end
-
-  describe '#remove_from' do
-    let(:action) { promotion.actions.first! }
-    let(:promotion) { create(:promotion, :with_order_adjustment) }
-
-    let!(:unrelated_adjustment) { create(:adjustment, order: order, source: nil) }
-
-    before do
-      action.perform(payload)
-      @action_adjustment = order.adjustments.where(source: action).first!
-    end
-
-    it 'removes the action adjustment' do
-      expect(order.adjustments).to match_array([unrelated_adjustment, @action_adjustment])
-
-      action.remove_from(order)
-
-      expect(order.adjustments).to eq([unrelated_adjustment])
-    end
-  end
-
-  shared_examples "destroying adjustments from incomplete orders" do
-    before(:each) do
-      action.calculator = Spree::Calculator::FlatRate.new(preferred_amount: 10)
-      promotion.promotion_actions = [action]
-    end
-
-    context "when order is not complete" do
-      it "should not keep the adjustment" do
-        action.perform(payload)
-        subject
-        expect(order.adjustments.count).to eq(0)
-      end
-    end
-
-    context "when order is complete" do
-      let(:order) do
-        create(:completed_order_with_totals, line_items_count: 1)
-      end
-
-      before(:each) do
-        action.perform(payload)
-        subject
-      end
-
-      it "should keep the adjustment" do
-        expect(order.adjustments.count).to eq(1)
-      end
-
-      it "should nullify the adjustment source" do
-        expect(order.adjustments.reload.first.source).to be_nil
-      end
-    end
-  end
-
-  context "#discard" do
-    subject { action.discard }
-    it_should_behave_like "destroying adjustments from incomplete orders"
-  end
-
-  context "#paranoia_destroy" do
-    subject { Spree::Deprecation.silence { action.paranoia_destroy } }
-    it_should_behave_like "destroying adjustments from incomplete orders"
-  end
-end

data/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Promotion::Actions::CreateItemAdjustments, type: :model do
-    let(:order) { create(:order_with_line_items, line_items_count: 1) }
-    let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: adjustment_amount) }
-    let(:adjustment_amount) { 10 }
-    let(:action) { promotion.actions.first! }
-    let(:line_item) { order.line_items.to_a.first }
-    let(:payload) { { order: order, promotion: promotion } }
-
-    before do
-      allow(action).to receive(:promotion).and_return(promotion)
-      promotion.promotion_actions = [action]
-    end
-
-    context "#perform" do
-      # Regression test for https://github.com/spree/spree/issues/3966
-      context "when calculator computes 0" do
-        let(:adjustment_amount) { 0 }
-
-        it "does not create an adjustment when calculator returns 0" do
-          action.perform(payload)
-          expect(action.adjustments).to be_empty
-        end
-      end
-
-      context "when calculator returns a non-zero value" do
-        let(:adjustment_amount) { 10 }
-
-        it "creates adjustment with item as adjustable" do
-          action.perform(payload)
-          expect(action.adjustments.count).to eq(1)
-          expect(line_item.adjustments).to eq(action.adjustments)
-        end
-
-        it "creates adjustment with self as source" do
-          action.perform(payload)
-          expect(line_item.adjustments.first.source).to eq action
-        end
-
-        it "does not perform twice on the same item" do
-          2.times { action.perform(payload) }
-          expect(action.adjustments.count).to eq(1)
-        end
-
-        context "with products rules" do
-          let(:rule) { double Spree::Promotion::Rules::Product }
-
-          before { allow(promotion).to receive(:eligible_rules) { [rule] } }
-
-          context "when the rule is actionable" do
-            before { allow(rule).to receive(:actionable?).and_return(true) }
-
-            it "creates an adjustment" do
-              expect {
-                expect {
-                  action.perform(payload)
-                }.to change { action.adjustments.count }.by(1)
-              }.to change { line_item.adjustments.count }.by(1)
-
-              expect(action.adjustments.last).to eq line_item.adjustments.last
-            end
-          end
-
-          context "when the rule is not actionable" do
-            before { allow(rule).to receive(:actionable?).and_return(false) }
-
-            it "does not create an adjustment" do
-              expect {
-                expect {
-                  action.perform(payload)
-                }.to_not change { action.adjustments.count }
-              }.to_not change { line_item.adjustments.count }
-            end
-          end
-        end
-
-        context "when a promotion code is used" do
-          let!(:promotion_code) { create(:promotion_code, promotion: promotion) }
-          let(:payload) { { order: order, promotion: promotion, promotion_code: promotion_code } }
-
-          it "should connect the adjustment to the promotion_code" do
-            expect {
-              action.perform(payload)
-            }.to change { line_item.adjustments.count }.by(1)
-            expect(line_item.adjustments.last.promotion_code).to eq promotion_code
-          end
-        end
-      end
-    end
-
-    context "#compute_amount" do
-      before { promotion.promotion_actions = [action] }
-
-      context "when the adjustable is actionable" do
-        it "calls compute on the calculator" do
-          expect(action.calculator).to receive(:compute).with(line_item).and_call_original
-          action.compute_amount(line_item)
-        end
-
-        context "calculator returns amount greater than item total" do
-          before do
-            action.calculator.preferred_amount = 300
-            allow(line_item).to receive_messages(amount: 100)
-          end
-
-          it "does not exceed it" do
-            expect(action.compute_amount(line_item)).to eql(-100)
-          end
-        end
-      end
-
-      context "when the adjustable is not actionable" do
-        before { allow(promotion).to receive(:line_item_actionable?) { false } }
-
-        it 'returns 0' do
-          expect(action.compute_amount(line_item)).to eql(0)
-        end
-      end
-    end
-
-    describe '#remove_from' do
-      # this adjustment should not get removed
-      let!(:other_adjustment) { create(:adjustment, adjustable: line_item, order: order, source: nil) }
-
-      before do
-        action.perform(payload)
-        @action_adjustment = line_item.adjustments.where(source: action).first!
-      end
-
-      it 'removes the action adjustment' do
-        expect(line_item.adjustments).to match_array([other_adjustment, @action_adjustment])
-
-        action.remove_from(order)
-
-        expect(line_item.adjustments).to eq([other_adjustment])
-      end
-    end
-
-    shared_examples "destroying adjustments from incomplete orders" do
-      let!(:action) { promotion.actions.first }
-      let(:other_action) { other_promotion.actions.first }
-      let(:promotion) { create(:promotion, :with_line_item_adjustment) }
-      let(:other_promotion) { create(:promotion, :with_line_item_adjustment) }
-
-      context 'with incomplete orders' do
-        let(:order) { create(:order) }
-
-        it 'destroys adjustments' do
-          order.adjustments.create!(label: 'Check', amount: 0, order: order, source: action)
-
-          expect {
-            subject
-          }.to change { Adjustment.count }.by(-1)
-        end
-      end
-
-      context 'with complete orders' do
-        let(:order) { create(:completed_order_with_totals) }
-
-        it "does not change adjustments for completed orders" do
-          order = create :order, completed_at: Time.current
-          adjustment = action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
-
-          expect {
-            expect {
-              subject
-            }.not_to change { adjustment.reload.source_id }
-          }.not_to change { Spree::Adjustment.count }
-
-          expect(adjustment.source).to eq(nil)
-          expect(Spree::PromotionAction.with_deleted.find(adjustment.source_id)).to be_present
-        end
-
-        it "doesnt mess with unrelated adjustments" do
-          order.adjustments.create!(label: "Check", amount: 0, order: order, source: action)
-
-          expect {
-            subject
-          }.not_to change { other_action.adjustments.count }
-        end
-      end
-    end
-
-    describe "#discard" do
-      subject { action.discard }
-      it_should_behave_like "destroying adjustments from incomplete orders"
-    end
-
-    describe "#paranoia_destroy" do
-      subject { Spree::Deprecation.silence { action.paranoia_destroy } }
-      it_should_behave_like "destroying adjustments from incomplete orders"
-    end
-  end
-end

data/spec/models/spree/promotion/actions/create_quantity_adjustments_spec.rb

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module Spree::Promotion::Actions
-  RSpec.describe CreateQuantityAdjustments do
-    let(:action) { CreateQuantityAdjustments.create!(calculator: calculator, promotion: promotion) }
-
-    let(:order) do
-      create(
-        :order_with_line_items,
-        line_items_attributes: line_items_attributes
-      )
-    end
-
-    let(:line_items_attributes) do
-      [
-        { price: 10, quantity: quantity }
-      ]
-    end
-
-    let(:quantity) { 1 }
-    let(:promotion) { FactoryBot.create :promotion }
-
-    describe "#compute_amount" do
-      subject { action.compute_amount(line_item) }
-
-      context "with a flat rate adjustment" do
-        let(:calculator) { FactoryBot.create :flat_rate_calculator, preferred_amount: 5 }
-
-        context "with a quantity group of 2" do
-          let(:line_item) { order.line_items.first }
-
-          before { action.preferred_group_size = 2 }
-
-          context "and an item with a quantity of 0" do
-            let(:quantity) { 0 }
-            it { is_expected.to eq 0 }
-          end
-
-          context "and an item with a quantity of 1" do
-            let(:quantity) { 1 }
-            it { is_expected.to eq 0 }
-          end
-
-          context "and an item with a quantity of 2" do
-            let(:quantity) { 2 }
-            it { is_expected.to eq(-10) }
-          end
-
-          context "and an item with a quantity of 3" do
-            let(:quantity) { 3 }
-            it { is_expected.to eq(-10) }
-          end
-
-          context "and an item with a quantity of 4" do
-            let(:quantity) { 4 }
-            it { is_expected.to eq(-20) }
-          end
-        end
-
-        context "with a quantity group of 3" do
-          before { action.preferred_group_size = 3 }
-
-          context "and 2x item A, 1x item B and 1x item C" do
-            let(:line_items_attributes) do
-              [
-                { price: 10, quantity: 2 },
-                { price: 10, quantity: 1 },
-                { price: 10, quantity: 1 },
-              ]
-            end
-
-            before { action.perform({ order: order, promotion: promotion }) }
-
-            describe "the adjustment for the first item" do
-              let(:line_item) { order.line_items.first }
-              it { is_expected.to eq(-10) }
-            end
-            describe "the adjustment for the second item" do
-              let(:line_item) { order.line_items.second }
-              it { is_expected.to eq(-5) }
-            end
-            describe "the adjustment for the third item" do
-              let(:line_item) { order.line_items.third }
-              it { is_expected.to eq 0 }
-            end
-          end
-        end
-
-        context "with multiple orders using the same action" do
-          let(:other_order) do
-            create(
-              :order_with_line_items,
-              line_items_attributes: [
-                { quantity: 3 }
-            ]
-            )
-          end
-
-          let(:line_item) { other_order.line_items.first }
-
-          before do
-            action.preferred_group_size = 2
-            action.perform({ order: other_order, promotion: promotion })
-          end
-
-          it { is_expected.to eq(-10) }
-        end
-      end
-
-      context "with a percentage based adjustment" do
-        let(:calculator) { FactoryBot.create :percent_on_item_calculator, preferred_percent: 10 }
-
-        let(:line_items_attributes) do
-          [
-            { price: 10, quantity: 1 }.merge(line_one_options),
-            { price: 10, quantity: 1 }.merge(line_two_options),
-          ]
-        end
-
-        let(:line_one_options) { {} }
-        let(:line_two_options) { {} }
-
-        context "with a quantity group of 3" do
-          before do
-            action.preferred_group_size = 3
-            action.perform({ order: order, promotion: promotion })
-          end
-
-          context "and 2x item A and 1x item B" do
-            let(:line_one_options) { { quantity: 2 } }
-
-            describe "the adjustment for the first item" do
-              let(:line_item) { order.line_items.first }
-              it { is_expected.to eq(-2) }
-            end
-            describe "the adjustment for the second item" do
-              let(:line_item) { order.line_items.second }
-              it { is_expected.to eq(-1) }
-            end
-          end
-
-          context "and the items cost different amounts" do
-            let(:line_one_options) { { quantity: 3 } }
-            let(:line_two_options) { { price: 20 } }
-
-            describe "the adjustment for the first item" do
-              let(:line_item) { order.line_items.first }
-              it { is_expected.to eq(-3) }
-            end
-            describe "the adjustment for the second item" do
-              let(:line_item) { order.line_items.second }
-              it { is_expected.to eq 0 }
-            end
-          end
-        end
-      end
-
-      context "with a tiered percentage based adjustment" do
-        let(:tiers) do
-          {
-            20 => 20,
-            40 => 30
-          }
-        end
-
-        let(:calculator) do
-          Spree::Calculator::TieredPercent.create(preferred_base_percent: 10, preferred_tiers: tiers)
-        end
-        let(:line_items_attributes) do
-          [
-            { price: 10, quantity: 1 }.merge(line_one_options),
-            { price: 10, quantity: 1 }.merge(line_two_options),
-          ]
-        end
-
-        let(:line_one_options) { {} }
-        let(:line_two_options) { {} }
-
-        context "with a quantity group of 3" do
-          before do
-            action.preferred_group_size = 3
-            action.perform({ order: order, promotion: promotion })
-          end
-
-          context "and 2x item A and 1x item B" do
-            let(:line_one_options) { { quantity: 2 } }
-
-            context "when amount falls within the first tier" do
-              describe "the adjustment for the first item" do
-                let(:line_item) { order.line_items.first }
-                it { is_expected.to eq(-4) }
-              end
-              describe "the adjustment for the second item" do
-                let(:line_item) { order.line_items.second }
-                it { is_expected.to eq(-2) }
-              end
-            end
-
-            context "when amount falls within the second tier" do
-              let(:line_two_options) { { price: 20 } }
-
-              describe "the adjustment for the first item" do
-                let(:line_item) { order.line_items.first }
-                it { is_expected.to eq(-6) }
-              end
-
-              describe "the adjustment for the second item" do
-                let(:line_item) { order.line_items.second }
-                it { is_expected.to eq(-6) }
-              end
-            end
-          end
-        end
-      end
-    end
-
-    # Regression test for https://github.com/solidusio/solidus/pull/1591
-    context "with unsaved line_item changes" do
-      let(:calculator) { FactoryBot.create :flat_rate_calculator }
-      let(:line_item) { order.line_items.first }
-
-      before do
-        order.line_items.first.promo_total = -11
-        action.compute_amount(line_item)
-      end
-
-      it "doesn't reload the line_items association" do
-        expect(order.line_items.first.promo_total).to eq(-11)
-      end
-    end
-
-    # Regression test for https://github.com/solidusio/solidus/pull/1591
-    context "applied to the order" do
-      let(:calculator) { FactoryBot.create :flat_rate_calculator }
-
-      before do
-        action.perform(order: order, promotion: promotion)
-        order.recalculate
-      end
-
-      it 'updates the order totals' do
-        expect(order).to have_attributes(
-          total: 100,
-          adjustment_total: -10
-        )
-      end
-
-      context "after updating item quantity" do
-        before do
-          order.line_items.first.update!(quantity: 2, price: 30)
-          order.recalculate
-        end
-
-        it 'updates the order totals' do
-          expect(order).to have_attributes(
-            total: 140,
-            adjustment_total: -20
-          )
-        end
-      end
-
-      context "after updating promotion amount" do
-        before do
-          calculator.update!(preferred_amount: 5)
-          order.recalculate
-        end
-
-        it 'updates the order totals' do
-          expect(order).to have_attributes(
-            total: 105,
-            adjustment_total: -5
-          )
-        end
-      end
-    end
-
-    describe Spree::Promotion::Actions::CreateQuantityAdjustments::PartialLineItem do
-      let!(:item) { FactoryBot.create :line_item, order: order, quantity: quantity, price: 10 }
-      let(:quantity) { 5 }
-
-      subject { described_class.new(item) }
-
-      it "has a reference to the parent order" do
-        expect(subject.order.id).to eq order.id
-      end
-
-      it "uses the `line_item.price` as a `line_item.amount`" do
-        expect(subject.amount).to eq item.price
-      end
-
-      it "has a currency" do
-        expect(subject.currency).to eq item.currency
-      end
-    end
-  end
-end