solidus_core 2.0.3 → 2.1.0.beta1

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

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 describe Spree::Promotion::Actions::FreeShipping, type: :model do
   let(:order) { create(:completed_order_with_totals) }
-  let(:promotion_code) { create(:promotion_code, value: 'somecode') }
-  let(:promotion) { promotion_code.promotion }
-  let(:action) { Spree::Promotion::Actions::FreeShipping.create }
+  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
@@ -37,4 +38,22 @@ describe Spree::Promotion::Actions::FreeShipping, type: :model do
       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/taxon_spec.rb

@@ -97,6 +97,32 @@ describe Spree::Promotion::Rules::Taxon, type: :model do
       end
     end
 
+    context 'with none match policy' do
+      before do
+        rule.preferred_match_policy = 'none'
+      end
+
+      context "none of the order's products are in listed taxon" do
+        before { rule.taxons << taxon2 }
+        it { expect(rule).to be_eligible(order) }
+      end
+
+      context "one of the order's products is in a listed taxon" do
+        before do
+          order.products.first.taxons << taxon
+          rule.taxons << taxon
+        end
+        it "should not be eligible" do
+          expect(rule).not_to be_eligible(order)
+        end
+        it "sets an error message" do
+          rule.eligible?(order)
+          expect(rule.eligibility_errors.full_messages.first).
+            to eq "Your cart contains a product from an excluded category that prevents this coupon code from being applied."
+        end
+      end
+    end
+
     context 'with an invalid match policy' do
       before do
         order.products.first.taxons << taxon

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Rules::UserRole, type: :model do
+  let(:rule) { described_class.new(preferred_role_ids: roles_for_rule) }
+  let(:user) { create(:user, spree_roles: roles_for_user) }
+  let(:roles_for_rule) { [] }
+  let(:roles_for_user) { [] }
+
+  subject { rule }
+
+  shared_examples 'eligibility' do
+    context 'no roles on rule' do
+      let(:roles_for_user) { [create(:role)] }
+      it 'should not be eligible' do
+        expect(rule).to_not be_eligible(order)
+      end
+    end
+
+    context 'no roles on user' do
+      let(:roles_for_rule) { [create(:role)] }
+      it 'should not be eligible' do
+        expect(rule).to_not be_eligible(order)
+      end
+    end
+
+    context 'mismatched roles' do
+      let(:roles_for_user) { [create(:role)] }
+      let(:roles_for_rule) { [create(:role)] }
+      it 'should not be eligible' do
+        expect(rule).to_not be_eligible(order)
+      end
+    end
+
+    context 'matching all roles' do
+      let(:roles_for_user) { [create(:role), create(:role)] }
+      let(:roles_for_rule) { roles_for_user }
+      it 'should be eligible' do
+        expect(rule).to be_eligible(order)
+      end
+    end
+  end
+
+  context '#eligible?(order)' do
+    context 'order with no user' do
+      let(:order) { Spree::Order.new }
+
+      it 'should not be eligible' do
+        expect(rule).to_not be_eligible(order)
+      end
+    end
+
+    context 'order with user' do
+      let(:order) { Spree::Order.new(user: user) }
+
+      context 'with any match policy' do
+        before { rule.preferred_match_policy = 'any' }
+
+        include_examples 'eligibility'
+
+        context 'one shared role' do
+          let(:shared_role) { create(:role) }
+          let(:roles_for_user) { [create(:role), shared_role] }
+          let(:roles_for_rule) { [create(:role), shared_role] }
+          it 'should be eligible' do
+            expect(rule).to be_eligible(order)
+          end
+        end
+      end
+
+      context 'with all match policy' do
+        before { rule.preferred_match_policy = 'all' }
+
+        include_examples 'eligibility'
+
+        context 'one shared role' do
+          let(:shared_role) { create(:role) }
+          let(:roles_for_user) { [create(:role), shared_role] }
+          let(:roles_for_rule) { [create(:role), shared_role] }
+          it 'should not be eligible' do
+            expect(rule).to_not be_eligible(order)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/promotion_action_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Spree::PromotionAction, type: :model do
+  describe '#remove_from' do
+    class MyPromotionAction < Spree::PromotionAction
+      def perform(options = {})
+        order = options[:order]
+        order.adjustments.create!(amount: 1, order: order, source: self, label: 'foo')
+        true
+      end
+    end
+
+    let(:action) { promotion.actions.first! }
+    let!(:promotion) { create(:promotion, promotion_actions: [MyPromotionAction.new]) }
+    let(:order) { create(:order) }
+
+    # this adjustment should not get removed
+    let!(:other_adjustment) { create(:adjustment, order: order, source: nil) }
+
+    before do
+      action.perform(order: order)
+      @action_adjustment = order.adjustments.where(source: action).first!
+    end
+
+    it 'removes the action adjustment' do
+      expect(order.adjustments).to match_array([other_adjustment, @action_adjustment])
+
+      expect(Spree::Deprecation).to(
+        receive(:warn).
+        with(/"MyPromotionAction" does not define #remove_from/, anything)
+      )
+
+      action.remove_from(order)
+
+      expect(order.adjustments).to eq([other_adjustment])
+    end
+  end
+end

data/spec/models/spree/promotion_handler/coupon_spec.rb

@@ -252,57 +252,59 @@ module Spree
 
         context "for an order with taxable line items" do
           let(:store) { create(:store) }
+          let(:order) { create(:order, store: store) }
+          let(:tax_category) { create(:tax_category, name: "Taxable Foo") }
+          let(:zone) { create(:zone, :with_country) }
+          let!(:tax_rate) { create(:tax_rate, amount: 0.1, tax_category: tax_category, zone: zone )}
+
           before(:each) do
-            @country = create(:country)
-            @zone = create(:zone, name: "Country Zone", default_tax: true, zone_members: [])
-            @zone.zone_members.create(zoneable: @country)
-            @category = Spree::TaxCategory.create name: "Taxable Foo"
-            @rate1 = Spree::TaxRate.create(
-              amount: 0.10,
-              calculator: Spree::Calculator::DefaultTax.create,
-              tax_category: @category,
-              zone: @zone
-            )
-
-            @order = Spree::Order.create!(store: store)
-            allow(@order).to receive_messages coupon_code: "10off"
+            expect(order).to receive(:tax_address).at_least(:once).and_return(Spree::Tax::TaxLocation.new(country: zone.countries.first))
           end
+
           context "and the product price is less than promo discount" do
             before(:each) do
+              expect(order).to receive(:coupon_code).at_least(:once).and_return("10off")
+
               3.times do |_i|
-                taxable = create(:product, tax_category: @category, price: 9.0)
-                @order.contents.add(taxable.master, 1)
+                taxable = create(:product, tax_category: tax_category, price: 9.0)
+                order.contents.add(taxable.master, 1)
               end
             end
+
             it "successfully applies the promo" do
               # 3 * (9 + 0.9)
-              expect(@order.total).to eq(29.7)
-              coupon = Coupon.new(@order)
+              expect(order.total).to eq(29.7)
+              coupon = Coupon.new(order)
               coupon.apply
               expect(coupon.success).to be_present
               # 3 * ((9 - [9,10].min) + 0)
-              expect(@order.reload.total).to eq(0)
-              expect(@order.additional_tax_total).to eq(0)
+              expect(order.reload.total).to eq(0)
+              expect(order.additional_tax_total).to eq(0)
             end
           end
+
           context "and the product price is greater than promo discount" do
             before(:each) do
+              expect(order).to receive(:coupon_code).at_least(:once).and_return("10off")
+
               3.times do |_i|
-                taxable = create(:product, tax_category: @category, price: 11.0)
-                @order.contents.add(taxable.master, 2)
+                taxable = create(:product, tax_category: tax_category, price: 11.0)
+                order.contents.add(taxable.master, 2)
               end
             end
+
             it "successfully applies the promo" do
               # 3 * (22 + 2.2)
-              expect(@order.total.to_f).to eq(72.6)
-              coupon = Coupon.new(@order)
+              expect(order.total.to_f).to eq(72.6)
+              coupon = Coupon.new(order)
               coupon.apply
               expect(coupon.success).to be_present
               # 3 * ( (22 - 10) + 1.2)
-              expect(@order.reload.total).to eq(39.6)
-              expect(@order.additional_tax_total).to eq(3.6)
+              expect(order.reload.total).to eq(39.6)
+              expect(order.additional_tax_total).to eq(3.6)
             end
           end
+
           context "and multiple quantity per line item" do
             before(:each) do
               twnty_off = create(:promotion, name: "promo", code: "20off")
@@ -310,22 +312,23 @@ module Spree
               Promotion::Actions::CreateItemAdjustments.create(promotion: twnty_off,
                                                                calculator: twnty_off_calc)
 
-              allow(@order).to receive(:coupon_code).and_call_original
-              allow(@order).to receive_messages coupon_code: "20off"
+              expect(order).to receive(:coupon_code).at_least(:once).and_return("20off")
+
               3.times do |_i|
-                taxable = create(:product, tax_category: @category, price: 10.0)
-                @order.contents.add(taxable.master, 2)
+                taxable = create(:product, tax_category: tax_category, price: 10.0)
+                order.contents.add(taxable.master, 2)
               end
             end
+
             it "successfully applies the promo" do
               # 3 * ((2 * 10) + 2.0)
-              expect(@order.total.to_f).to eq(66)
-              coupon = Coupon.new(@order)
+              expect(order.total.to_f).to eq(66)
+              coupon = Coupon.new(order)
               coupon.apply
               expect(coupon.success).to be_present
               # 0
-              expect(@order.reload.total).to eq(0)
-              expect(@order.additional_tax_total).to eq(0)
+              expect(order.reload.total).to eq(0)
+              expect(order.additional_tax_total).to eq(0)
             end
           end
         end

data/spec/models/spree/promotion_handler/free_shipping_spec.rb

@@ -6,40 +6,39 @@ module Spree
       let(:order) { create(:order) }
       let(:shipment) { create(:shipment, order: order ) }
 
-      let(:promotion) { Promotion.create!(name: "Free Shipping") }
-      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
-      let!(:action) { Promotion::Actions::FreeShipping.create(promotion: promotion) }
+      let(:action) { Spree::Promotion::Actions::FreeShipping.new }
 
       subject { Spree::PromotionHandler::FreeShipping.new(order) }
 
-      context "activates in Shipment level" do
+      context 'with apply_automatically' do
+        let!(:promotion) { create(:promotion, apply_automatically: true, promotion_actions: [action]) }
+
         it "creates the adjustment" do
           expect { subject.activate }.to change { shipment.adjustments.count }.by(1)
         end
       end
 
-      context "if promo has a code" do
-        let!(:promotion_code) { create(:promotion_code, promotion: promotion) }
-
-        it "does adjust the shipment when applied to order" do
-          pending "broken by 2-2-dev merge"
-          order.order_promotions.create!(promotion: promotion, promotion_code: promotion_code)
-
-          expect { subject.activate }.to change { shipment.adjustments.count }
-        end
+      context 'with a code' do
+        let!(:promotion) { create(:promotion, code: 'freeshipping', promotion_actions: [action]) }
 
-        it "does not adjust the shipment when not applied to order" do
-          expect { subject.activate }.to_not change { shipment.adjustments.count }
-        end
-      end
+        context 'when already applied' do
+          before do
+            order.order_promotions.create!(promotion: promotion, promotion_code: promotion.codes.first)
+          end
 
-      context "if promo has a path" do
-        before do
-          promotion.update_column(:path, "path")
+          it 'adjusts the shipment' do
+            expect {
+              subject.activate
+            }.to change { shipment.adjustments.count }
+          end
         end
 
-        it "does not adjust the shipment" do
-          expect { subject.activate }.to_not change { shipment.adjustments.count }
+        context 'when not already applied' do
+          it 'does not adjust the shipment' do
+            expect {
+              subject.activate
+            }.to_not change { shipment.adjustments.count }
+          end
         end
       end
     end

data/spec/models/spree/promotion_spec.rb

@@ -142,6 +142,30 @@ describe Spree::Promotion, type: :model do
           expect(promotion.activate(@payload)).to be true
           expect(promotion.orders.first).to eql @order
         end
+
+        it 'keeps in-memory associations updated' do
+          # load all the relevant associations into memory
+          promotion.order_promotions.to_a
+          promotion.orders.to_a
+          @order.order_promotions.to_a
+          @order.promotions.to_a
+
+          expect(promotion.order_promotions.size).to eq(0)
+          expect(promotion.orders.size).to eq(0)
+          expect(@order.order_promotions.size).to eq(0)
+          expect(@order.promotions.size).to eq(0)
+
+          expect(
+            promotion.activate(@payload)
+          ).to eq(true)
+
+          aggregate_failures do
+            expect(promotion.order_promotions.size).to eq(1)
+            expect(promotion.orders.size).to eq(1)
+            expect(@order.order_promotions.size).to eq(1)
+            expect(@order.promotions.size).to eq(1)
+          end
+        end
       end
       context "when not activated" do
         it "will not assign the order" do
@@ -176,6 +200,25 @@ describe Spree::Promotion, type: :model do
     end
   end
 
+  describe '#remove_from' do
+    let(:promotion) { create(:promotion, :with_line_item_adjustment) }
+    let(:order) { create(:order_with_line_items) }
+
+    before do
+      promotion.activate(order: order)
+    end
+
+    it 'removes the promotion' do
+      expect(order.promotions).to include(promotion)
+      expect(order.line_items.flat_map(&:adjustments)).to be_present
+
+      promotion.remove_from(order)
+
+      expect(order.promotions).to be_empty
+      expect(order.line_items.flat_map(&:adjustments)).to be_empty
+    end
+  end
+
   describe "#usage_limit_exceeded?" do
     subject { promotion.usage_limit_exceeded? }
 
@@ -554,8 +597,7 @@ describe Spree::Promotion, type: :model do
           allow(rule2).to receive_messages(eligible?: true, applicable?: true)
 
           promotion.promotion_rules = [rule1, rule2]
-          allow(promotion).to receive_message_chain(:rules, :none?).and_return(false)
-          allow(promotion).to receive_message_chain(:rules, :for).and_return(promotion.promotion_rules)
+          allow(promotion.promotion_rules).to receive(:for).and_return(promotion.promotion_rules)
         end
         it "returns the eligible rules" do
           expect(promotion.eligible_rules(promotable)).to eq [rule1, rule2]
@@ -573,8 +615,7 @@ describe Spree::Promotion, type: :model do
           allow(rule2).to receive_messages(eligible?: false, applicable?: true, eligibility_errors: errors)
 
           promotion.promotion_rules = [rule1, rule2]
-          allow(promotion).to receive_message_chain(:rules, :none?).and_return(false)
-          allow(promotion).to receive_message_chain(:rules, :for).and_return(promotion.promotion_rules)
+          allow(promotion.promotion_rules).to receive(:for).and_return(promotion.promotion_rules)
         end
         it "returns nil" do
           expect(promotion.eligible_rules(promotable)).to be_nil
@@ -606,8 +647,7 @@ describe Spree::Promotion, type: :model do
           allow(rule).to receive_messages(eligible?: false, applicable?: true, eligibility_errors: errors)
 
           promotion.promotion_rules = [rule]
-          allow(promotion).to receive_message_chain(:rules, :for).and_return(promotion.promotion_rules)
-          allow(promotion).to receive_message_chain(:rules, :none?).and_return(false)
+          allow(promotion.promotion_rules).to receive(:for).and_return(promotion.promotion_rules)
         end
         it "returns nil" do
           expect(promotion.eligible_rules(promotable)).to be_nil