spree_core 3.1.14 → 3.2.0.rc1

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

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+module Spree
+  class Promotion
+    module Actions
+      describe CreateItemAdjustments, type: :model do
+        let(:order) { create(:order) }
+        let(:promotion) { create(:promotion) }
+        let(:action) { CreateItemAdjustments.new }
+        let!(:line_item) { create(:line_item, order: order) }
+        let(:payload) { { order: order, promotion: promotion } }
+
+        before do
+          allow(action).to receive(:promotion).and_return(promotion)
+          promotion.promotion_actions = [action]
+        end
+
+        it_behaves_like 'an adjustment source'
+
+        context "#perform" do
+          # Regression test for #3966
+          context "when calculator computes 0" do
+            before do
+              allow(action).to receive_messages compute_amount: 0
+            end
+
+            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
+            before do
+              promotion.promotion_actions = [action]
+              allow(action).to receive_messages compute_amount: 10
+            end
+
+            it "creates adjustment with item as adjustable" do
+              action.perform(payload)
+              expect(action.adjustments.count).to eq(1)
+              expect(line_item.reload.adjustments).to eq(action.adjustments)
+            end
+
+            it "creates adjustment with self as source" do
+              action.perform(payload)
+              expect(line_item.reload.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!(:second_line_item) { create(:line_item, order: order) }
+              let(:rule) { double Spree::Promotion::Rules::Product }
+
+              before do
+                allow(promotion).to receive(:eligible_rules) { [rule] }
+                allow(rule).to receive(:actionable?).and_return(true, false)
+              end
+
+              it "does not create adjustments for line_items not in product rule" do
+                action.perform(payload)
+                expect(action.adjustments.count).to eql 1
+                expect(line_item.reload.adjustments).to match_array action.adjustments
+                expect(second_line_item.reload.adjustments).to be_empty
+              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
+              allow(action.calculator).to receive(:compute).and_return(10)
+              expect(action.calculator).to receive(:compute).with(line_item)
+              action.compute_amount(line_item)
+            end
+
+            context "calculator returns amount greater than item total" do
+              before do
+                expect(action.calculator).to receive(:compute).with(line_item).and_return(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
+
+        context "#destroy" do
+          let!(:action) { CreateItemAdjustments.create! }
+          let(:other_action) { CreateItemAdjustments.create! }
+          before { promotion.promotion_actions = [other_action] }
+
+          it "destroys adjustments for incompleted orders" do
+            order = Order.create
+            action.adjustments.create!(label: "Check",
+                                       amount: 0,
+                                       order: order,
+                                       adjustable: line_item)
+
+            expect {
+              action.destroy
+            }.to change { Adjustment.count }.by(-1)
+          end
+
+          it "nullifies adjustments for completed orders" do
+            order = Order.create(completed_at: Time.current)
+            adjustment = action.adjustments.create!(label: "Check",
+                                                    amount: 0,
+                                                    order: order,
+                                                    adjustable: line_item)
+
+            expect {
+              action.destroy
+            }.to change { adjustment.reload.source_id }.from(action.id).to nil
+          end
+
+          it "doesnt mess with unrelated adjustments" do
+            other_action.adjustments.create!(label: "Check",
+                                             amount: 0,
+                                             order: order,
+                                             adjustable: line_item)
+
+            expect {
+              action.destroy
+            }.not_to change { other_action.adjustments.count }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Actions::CreateLineItems, type: :model do
+  let(:order) { create(:order) }
+  let(:action) { Spree::Promotion::Actions::CreateLineItems.create }
+  let(:promotion) { stub_model(Spree::Promotion) }
+  let(:shirt) { create(:variant) }
+  let(:mug) { create(:variant) }
+  let(:payload) { { order: order } }
+
+  def empty_stock(variant)
+    variant.stock_items.update_all(backorderable: false)
+    variant.stock_items.each(&:reduce_count_on_hand_to_zero)
+  end
+
+  context "#perform" do
+    before do
+      allow(action).to receive_messages promotion: promotion
+      action.promotion_action_line_items.create!(
+        variant: mug,
+        quantity: 1
+      )
+      action.promotion_action_line_items.create!(
+        variant: shirt,
+        quantity: 2
+      )
+    end
+
+    context "order is eligible" do
+      before do
+        allow(promotion).to receive_messages eligible: true
+      end
+
+      it "adds line items to order with correct variant and quantity" do
+        action.perform(payload)
+        expect(order.line_items.count).to eq(2)
+        line_item = order.line_items.find_by_variant_id(mug.id)
+        expect(line_item).not_to be_nil
+        expect(line_item.quantity).to eq(1)
+      end
+
+      it "only adds the delta of quantity to an order" do
+        order.contents.add(shirt, 1)
+        action.perform(payload)
+        line_item = order.line_items.find_by_variant_id(shirt.id)
+        expect(line_item).not_to be_nil
+        expect(line_item.quantity).to eq(2)
+      end
+
+      it "doesn't add if the quantity is greater" do
+        order.contents.add(shirt, 3)
+        action.perform(payload)
+        line_item = order.line_items.find_by_variant_id(shirt.id)
+        expect(line_item).not_to be_nil
+        expect(line_item.quantity).to eq(3)
+      end
+
+      it "doesn't try to add an item if it's out of stock" do
+        empty_stock(mug)
+        empty_stock(shirt)
+
+        expect(order.contents).to_not receive(:add)
+        action.perform(order: order)
+      end
+    end
+  end
+
+  describe "#item_available?" do
+    let(:item_out_of_stock) do
+      action.promotion_action_line_items.create!(variant: mug, quantity: 1)
+    end
+
+    let(:item_in_stock) do
+      action.promotion_action_line_items.create!(variant: shirt, quantity: 1)
+    end
+
+    it "returns false if the item is out of stock" do
+      empty_stock(mug)
+      expect(action.item_available? item_out_of_stock).to be false
+    end
+
+    it "returns true if the item is in stock" do
+      expect(action.item_available? item_in_stock).to be true
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Actions::FreeShipping, type: :model do
+  let(:order) { create(:completed_order_with_totals) }
+  let(:promotion) { create(:promotion) }
+  let(:action) { Spree::Promotion::Actions::FreeShipping.create }
+  let(:payload) { { order: order } }
+
+  it_behaves_like 'an adjustment source'
+
+  # From promotion spec:
+  context "#perform" do
+    before do
+      order.shipments << create(:shipment)
+      promotion.promotion_actions << action
+    end
+
+    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.credits_count).to eq(2)
+      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)
+    end
+
+    it "should not create a discount when order already has one from this promotion" do
+      expect(action.perform(payload)).to be true
+      expect(action.perform(payload)).to be false
+      expect(promotion.credits_count).to eq(2)
+      expect(order.shipment_adjustments.count).to eq(2)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Rules::Country, type: :model do
+  let(:rule) { Spree::Promotion::Rules::Country.new }
+  let(:order) { create(:order) }
+  let(:country) { create(:country) }
+  let(:other_country) { create(:country) }
+
+  before { allow(Spree::Country).to receive(:default) { other_country.id } }
+
+  context 'preferred country is set' do
+    before { rule.preferred_country_id = country.id }
+
+    it 'should be eligible for correct country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { country.id }
+      expect(rule).to be_eligible(order)
+    end
+
+    it 'should not be eligible for incorrect country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { other_country.id }
+      expect(rule).not_to be_eligible(order)
+    end
+  end
+
+  context 'preferred country is not set' do
+    it 'should be eligible for default country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { other_country.id }
+      expect(rule).to be_eligible(order)
+    end
+
+    it 'should not be eligible for incorrect country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { country.id }
+      expect(rule).not_to be_eligible(order)
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+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.org' }
+      before { allow(order).to receive_messages email: 'user@spreecommerce.org' }
+
+      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/item_total_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Rules::ItemTotal, type: :model do
+  let(:rule) { Spree::Promotion::Rules::ItemTotal.new }
+  let(:order) { double(:order) }
+
+  before { rule.preferred_amount_min = 50 }
+  before { rule.preferred_amount_max = 60 }
+
+  context "preferred operator_min set to gt and preferred operator_max set to lt" do
+    before do
+      rule.preferred_operator_min = 'gt'
+      rule.preferred_operator_max = 'lt'
+    end
+
+    context "and item total is lower than prefered maximum amount" do
+
+      context "and item total is higher than prefered minimum amount" do
+        it "should be eligible" do
+          allow(order).to receive_messages item_total: 51
+          expect(rule).to be_eligible(order)
+        end
+      end
+
+      context "and item total is equal to the prefered minimum amount" do
+
+        before { allow(order).to receive_messages item_total: 50 }
+
+        it "should not be eligible" do
+          expect(rule).to_not be_eligible(order)
+        end
+
+        it "set an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can't be applied to orders less than or equal to $50.00."
+        end
+      end
+
+      context "and item total is lower to the prefered minimum amount" do
+        before { allow(order).to receive_messages item_total: 49 }
+
+        it "should not be eligible" do
+          expect(rule).to_not be_eligible(order)
+        end
+
+        it "set an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can't be applied to orders less than or equal to $50.00."
+        end
+      end
+    end
+
+    context "and item total is equal to the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 60 }
+
+      it "should not be eligible" do
+        expect(rule).to_not be_eligible(order)
+      end
+
+      it "set an error message" do
+        rule.eligible?(order)
+        expect(rule.eligibility_errors.full_messages.first).
+          to eq "This coupon code can't be applied to orders higher than $60.00."
+      end
+    end
+
+    context "and item total is higher than the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 61 }
+
+      it "should not be eligible" do
+        expect(rule).to_not be_eligible(order)
+      end
+
+      it "set an error message" do
+        rule.eligible?(order)
+        expect(rule.eligibility_errors.full_messages.first).
+          to eq "This coupon code can't be applied to orders higher than $60.00."
+      end
+    end
+
+  end
+
+  context "preferred operator set to gt and preferred operator_max set to lte" do
+    before do
+      rule.preferred_operator_min = 'gt'
+      rule.preferred_operator_max = 'lte'
+    end
+
+    context "and item total is lower than prefered maximum amount" do
+
+      context "and item total is higher than prefered minimum amount" do
+        it "should be eligible" do
+          allow(order).to receive_messages item_total: 51
+          expect(rule).to be_eligible(order)
+        end
+      end
+
+      context "and item total is equal to the prefered minimum amount" do
+
+        before { allow(order).to receive_messages item_total: 50 }
+
+        it "should not be eligible" do
+          expect(rule).to_not be_eligible(order)
+        end
+
+        it "set an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can't be applied to orders less than or equal to $50.00."
+        end
+      end
+
+      context "and item total is lower to the prefered minimum amount" do
+        before { allow(order).to receive_messages item_total: 49 }
+
+        it "should not be eligible" do
+          expect(rule).to_not be_eligible(order)
+        end
+
+        it "set an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can't be applied to orders less than or equal to $50.00."
+        end
+      end
+    end
+
+    context "and item total is equal to the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 60 }
+
+      it "should not be eligible" do
+        expect(rule).to be_eligible(order)
+      end
+    end
+
+    context "and item total is higher than the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 61 }
+
+      it "should not be eligible" do
+        expect(rule).to_not be_eligible(order)
+      end
+
+      it "set an error message" do
+        rule.eligible?(order)
+        expect(rule.eligibility_errors.full_messages.first).
+          to eq "This coupon code can't be applied to orders higher than $60.00."
+      end
+    end
+  end
+
+  context "preferred operator set to gte and preferred operator_max set to lt" do
+    before do
+      rule.preferred_operator_min = 'gte'
+      rule.preferred_operator_max = 'lt'
+    end
+
+    context "and item total is lower than prefered maximum amount" do
+
+      context "and item total is higher than prefered minimum amount" do
+        it "should be eligible" do
+          allow(order).to receive_messages item_total: 51
+          expect(rule).to be_eligible(order)
+        end
+      end
+
+      context "and item total is equal to the prefered minimum amount" do
+
+        before { allow(order).to receive_messages item_total: 50 }
+
+        it "should not be eligible" do
+          expect(rule).to be_eligible(order)
+        end
+      end
+
+      context "and item total is lower to the prefered minimum amount" do
+        before { allow(order).to receive_messages item_total: 49 }
+
+        it "should not be eligible" do
+          expect(rule).to_not be_eligible(order)
+        end
+
+        it "set an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can't be applied to orders less than $50.00."
+        end
+      end
+    end
+
+    context "and item total is equal to the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 60 }
+
+      it "should not be eligible" do
+        expect(rule).to_not be_eligible(order)
+      end
+
+      it "set an error message" do
+        rule.eligible?(order)
+        expect(rule.eligibility_errors.full_messages.first).
+          to eq "This coupon code can't be applied to orders higher than $60.00."
+      end
+    end
+
+    context "and item total is higher than the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 61 }
+
+      it "should not be eligible" do
+        expect(rule).to_not be_eligible(order)
+      end
+
+      it "set an error message" do
+        rule.eligible?(order)
+        expect(rule.eligibility_errors.full_messages.first).
+          to eq "This coupon code can't be applied to orders higher than $60.00."
+      end
+    end
+
+  end
+
+  context "preferred operator set to gte and preferred operator_max set to lte" do
+    before do
+      rule.preferred_operator_min = 'gte'
+      rule.preferred_operator_max = 'lte'
+    end
+
+    context "and item total is lower than prefered maximum amount" do
+      context "and item total is higher than prefered minimum amount" do
+        it "should be eligible" do
+          allow(order).to receive_messages item_total: 51
+          expect(rule).to be_eligible(order)
+        end
+      end
+
+      context "and item total is equal to the prefered minimum amount" do
+
+        before { allow(order).to receive_messages item_total: 50 }
+
+        it "should not be eligible" do
+          expect(rule).to be_eligible(order)
+        end
+      end
+
+      context "and item total is lower to the prefered minimum amount" do
+        before { allow(order).to receive_messages item_total: 49 }
+
+        it "should not be eligible" do
+          expect(rule).to_not be_eligible(order)
+        end
+
+        it "set an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "This coupon code can't be applied to orders less than $50.00."
+        end
+      end
+    end
+
+    context "and item total is equal to the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 60 }
+
+      it "should not be eligible" do
+        expect(rule).to be_eligible(order)
+      end
+    end
+
+    context "and item total is higher than the prefered maximum amount" do
+      before { allow(order).to receive_messages item_total: 61 }
+
+      it "should not be eligible" do
+        expect(rule).to_not be_eligible(order)
+      end
+
+      it "set an error message" do
+        rule.eligible?(order)
+        expect(rule.eligibility_errors.full_messages.first).
+          to eq "This coupon code can't be applied to orders higher than $60.00."
+      end
+    end
+  end
+end