solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,198 @@
+# 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

@@ -0,0 +1,298 @@
+# 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

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Promotion::Actions::FreeShipping, type: :model do
+  let(:order) { create(:completed_order_with_totals) }
+  let(:shipment) { order.shipments.to_a.first }
+  let(:promotion) { create(:promotion, code: 'somecode', promotion_actions: [action]) }
+  let(:action) { Spree::Promotion::Actions::FreeShipping.new }
+  let(:payload) { { order: order, promotion_code: promotion_code } }
+  let(:promotion_code) { promotion.codes.first! }
+
+  # From promotion spec:
+  context "#perform" do
+    before do
+      order.shipments << create(:shipment)
+      promotion.promotion_actions << action
+    end
+
+    context "when valid" do
+      it "should create a discount with correct negative amount" do
+        expect(order.shipments.count).to eq(2)
+        expect(order.shipments.first.cost).to eq(100)
+        expect(order.shipments.last.cost).to eq(100)
+        expect(action.perform(payload)).to be true
+        expect(promotion.usage_count).to eq(1)
+        expect(order.shipment_adjustments.count).to eq(2)
+        expect(order.shipment_adjustments.first.amount.to_i).to eq(-100)
+        expect(order.shipment_adjustments.last.amount.to_i).to eq(-100)
+        expect(order.shipment_adjustments.map(&:promotion_code)).to eq [promotion_code, promotion_code]
+      end
+    end
+
+    context "when order already has one from this promotion" do
+      it "should not create a discount" do
+        expect(action.perform(payload)).to be true
+        expect(action.perform(payload)).to be false
+        expect(promotion.usage_count).to eq(1)
+        expect(order.shipment_adjustments.count).to eq(2)
+      end
+    end
+  end
+
+  describe '#remove_from' do
+    # this adjustment should not get removed
+    let!(:other_adjustment) { create(:adjustment, adjustable: shipment, order: order, source: nil) }
+
+    before do
+      action.perform(payload)
+      @action_adjustment = shipment.adjustments.where(source: action).first!
+    end
+
+    it 'removes the action adjustment' do
+      expect(shipment.adjustments).to match_array([other_adjustment, @action_adjustment])
+
+      action.remove_from(order)
+
+      expect(shipment.adjustments).to eq([other_adjustment])
+    end
+  end
+end

data/spec/models/spree/promotion/rules/first_order_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Promotion::Rules::FirstOrder, type: :model do
+  let(:rule) { Spree::Promotion::Rules::FirstOrder.new }
+  let(:order) { mock_model(Spree::Order, user: nil, email: nil) }
+  let(:user) { mock_model(Spree::LegacyUser) }
+
+  context "without a user or email" do
+    it { expect(rule).not_to be_eligible(order) }
+    it "sets an error message" do
+      rule.eligible?(order)
+      expect(rule.eligibility_errors.full_messages.first).
+        to eq "You need to login or provide your email before applying this coupon code."
+    end
+  end
+
+  context "first order" do
+    context "for a signed user" do
+      context "with no completed orders" do
+        before(:each) do
+          allow(user).to receive_message_chain(:orders, complete: [])
+        end
+
+        specify do
+          allow(order).to receive_messages(user: user)
+          expect(rule).to be_eligible(order)
+        end
+
+        it "should be eligible when user passed in payload data" do
+          expect(rule).to be_eligible(order, user: user)
+        end
+      end
+
+      context "with completed orders" do
+        before(:each) do
+          allow(order).to receive_messages(user: user)
+        end
+
+        it "should be eligible when checked against first completed order" do
+          allow(user).to receive_message_chain(:orders, complete: [order])
+          expect(rule).to be_eligible(order)
+        end
+
+        context "with another order" do
+          before { allow(user).to receive_message_chain(:orders, complete: [mock_model(Spree::Order)]) }
+          it { expect(rule).not_to be_eligible(order) }
+          it "sets an error message" do
+            rule.eligible?(order)
+            expect(rule.eligibility_errors.full_messages.first).
+              to eq "This coupon code can only be applied to your first order."
+          end
+        end
+      end
+    end
+
+    context "for a guest user" do
+      let(:email) { 'user@spreecommerce.com' }
+      before { allow(order).to receive_messages email: 'user@spreecommerce.com' }
+
+      context "with no other orders" do
+        it { expect(rule).to be_eligible(order) }
+      end
+
+      context "with another order" do
+        before { allow(rule).to receive_messages(orders_by_email: [mock_model(Spree::Order)]) }
+        it { expect(rule).not_to be_eligible(order) }
+        it "sets an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can only be applied to your first order."
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/promotion/rules/first_repeat_purchase_since_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Promotion::Rules::FirstRepeatPurchaseSince do
+  describe "#applicable?" do
+    subject { described_class.new.applicable?(promotable) }
+
+    context "when the promotable is an order" do
+      let(:promotable) { Spree::Order.new }
+
+      it { is_expected.to be true }
+    end
+
+    context "when the promotable is not a order" do
+      let(:promotable) { Spree::LineItem.new }
+
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "eligible?" do
+    let(:instance) { described_class.new }
+    subject { instance.eligible?(order) }
+
+    before do
+      instance.preferred_days_ago = 365
+    end
+
+    context "when the order does not have a user" do
+      let(:order) { Spree::Order.new }
+
+      it { is_expected.to be false }
+    end
+
+    context "when the order has a user" do
+      let(:order) { create :order }
+      let(:user) { order.user }
+
+      context "when the user has completed orders" do
+        let(:order_completion_date_1) { 1.day.ago }
+        let(:order_completion_date_2) { 1.day.ago }
+        before do
+          old_order_1 = create :completed_order_with_totals, user: user
+          old_order_1.update_attributes(completed_at: order_completion_date_1)
+
+          old_order_2 = create :completed_order_with_totals, user: user
+          old_order_2.update_attributes(completed_at: order_completion_date_2)
+        end
+
+        context "the last completed order was greater than the preferred days ago" do
+          let(:order_completion_date_1) { 14.months.ago }
+          let(:order_completion_date_2) { 13.months.ago }
+
+          it { is_expected.to be true }
+        end
+
+        context "the last completed order was less than the preferred days ago" do
+          let(:order_completion_date_1) { 14.months.ago }
+          let(:order_completion_date_2) { 11.months.ago }
+
+          it { is_expected.to be false }
+        end
+      end
+
+      context "when the user has no completed orders " do
+        it { is_expected.to be false }
+      end
+    end
+  end
+end