solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/promotion_code_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::PromotionCode do
+  context 'callbacks' do
+    subject { promotion_code.save }
+
+    describe '#normalize_code' do
+      let(:promotion) { create(:promotion, code: code) }
+      let(:promotion_code) { promotion.codes.first }
+
+      before { subject }
+
+      context 'with mixed case' do
+        let(:code) { 'NewCoDe' }
+
+        it 'downcases the value before saving' do
+          expect(promotion_code.value).to eq('newcode')
+        end
+      end
+
+      context 'with extra spacing' do
+        let(:code) { ' new code ' }
+        it 'removes surrounding whitespace' do
+          expect(promotion_code.value).to eq 'new code'
+        end
+      end
+    end
+  end
+
+  describe "#usage_limit_exceeded?" do
+    subject { code.usage_limit_exceeded? }
+
+    shared_examples "it should" do
+      context "when there is a usage limit" do
+        context "and the limit is not exceeded" do
+          let(:usage_limit) { 10 }
+          it { is_expected.to be_falsy }
+        end
+        context "and the limit is exceeded" do
+          let(:usage_limit) { 1 }
+          context "on a different order" do
+            before do
+              FactoryBot.create(
+                :completed_order_with_promotion,
+                promotion: promotion
+              )
+              code.adjustments.update_all(eligible: true)
+            end
+            it { is_expected.to be_truthy }
+          end
+          context "on the same order" do
+            it { is_expected.to be_falsy }
+          end
+        end
+      end
+      context "when there is no usage limit" do
+        let(:usage_limit) { nil }
+        it { is_expected.to be_falsy }
+      end
+    end
+
+    let(:code) { promotion.codes.first }
+
+    context "with an order-level adjustment" do
+      let(:promotion) do
+        FactoryBot.create(
+          :promotion,
+          :with_order_adjustment,
+          code: "discount",
+          per_code_usage_limit: usage_limit
+        )
+      end
+      let(:promotable) do
+        FactoryBot.create(
+          :completed_order_with_promotion,
+          promotion: promotion
+        )
+      end
+      it_behaves_like "it should"
+    end
+
+    context "with an item-level adjustment" do
+      let(:promotion) do
+        FactoryBot.create(
+          :promotion,
+          :with_line_item_adjustment,
+          code: "discount",
+          per_code_usage_limit: usage_limit
+        )
+      end
+      before do
+        promotion.actions.first.perform({
+          order: order,
+          promotion: promotion,
+          promotion_code: code
+        })
+      end
+      context "when there are multiple line items" do
+        let(:order) { FactoryBot.create(:order_with_line_items, line_items_count: 2) }
+        describe "the first item" do
+          let(:promotable) { order.line_items.first }
+          it_behaves_like "it should"
+        end
+        describe "the second item" do
+          let(:promotable) { order.line_items.last }
+          it_behaves_like "it should"
+        end
+      end
+      context "when there is a single line item" do
+        let(:order) { FactoryBot.create(:order_with_line_items) }
+        let(:promotable) { order.line_items.first }
+        it_behaves_like "it should"
+      end
+    end
+  end
+
+  describe "#usage_count" do
+    let(:promotion) do
+      FactoryBot.create(
+        :promotion,
+        :with_order_adjustment,
+        code: "discount"
+      )
+    end
+    let(:code) { promotion.codes.first }
+
+    subject { code.usage_count }
+
+    context "when the code is applied to a non-complete order" do
+      let(:order) { FactoryBot.create(:order_with_line_items) }
+      before { promotion.activate(order: order, promotion_code: code) }
+      it { is_expected.to eq 0 }
+    end
+    context "when the code is applied to a complete order" do
+      let!(:order) do
+        FactoryBot.create(
+          :completed_order_with_promotion,
+          promotion: promotion
+        )
+      end
+      context "and the promo is eligible" do
+        it { is_expected.to eq 1 }
+      end
+      context "and the promo is ineligible" do
+        before { order.adjustments.promotion.update_all(eligible: false) }
+        it { is_expected.to eq 0 }
+      end
+    end
+  end
+
+  describe "completing multiple orders with the same code", slow: true do
+    let(:promotion) do
+      FactoryBot.create(
+        :promotion,
+        :with_order_adjustment,
+        code: "discount",
+        per_code_usage_limit: 1,
+        weighted_order_adjustment_amount: 10
+      )
+    end
+    let(:code) { promotion.codes.first }
+    let(:order) do
+      FactoryBot.create(:order_with_line_items, line_items_price: 40, shipment_cost: 0).tap do |order|
+        FactoryBot.create(:payment, amount: 30, order: order)
+        promotion.activate(order: order, promotion_code: code)
+      end
+    end
+    let(:promo_adjustment) { order.adjustments.promotion.first }
+    before do
+      order.next! until order.can_complete?
+
+      FactoryBot.create(:order_with_line_items, line_items_price: 40, shipment_cost: 0).tap do |order|
+        FactoryBot.create(:payment, amount: 30, order: order)
+        promotion.activate(order: order, promotion_code: code)
+        order.next! until order.can_complete?
+        order.complete!
+      end
+    end
+
+    it "makes the promotion ineligible" do
+      expect{
+        order.complete
+      }.to change{ promo_adjustment.reload.eligible }.to(false)
+    end
+
+    it "adjusts the promo_total" do
+      expect{
+        order.complete
+      }.to change(order, :promo_total).by(10)
+    end
+
+    it "increases the total to remove the promo" do
+      expect{
+        order.complete
+      }.to change(order, :total).from(30).to(40)
+    end
+
+    it "resets the state of the order" do
+      expect{
+        order.complete
+      }.to change{ order.reload.state }.from("confirm").to("address")
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  module PromotionHandler
+    RSpec.describe Cart, type: :model do
+      let(:line_item) { create(:line_item) }
+      let(:order) { line_item.order }
+      let(:promotion) { create(:promotion, apply_automatically: true) }
+      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
+
+      subject { Cart.new(order, line_item) }
+
+      shared_context "creates the adjustment" do
+        it "creates the adjustment" do
+          expect {
+            subject.activate
+          }.to change { adjustable.adjustments.count }.by(1)
+        end
+      end
+
+      shared_context "creates an order promotion" do
+        it "connects the promotion to the order" do
+          expect {
+            subject.activate
+          }.to change { order.promotions.reload.to_a }.from([]).to([promotion])
+        end
+      end
+
+      context "activates in LineItem level" do
+        let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
+        let(:adjustable) { line_item }
+
+        context "promotion with no rules" do
+          include_context "creates the adjustment"
+          include_context "creates an order promotion"
+
+          context "for a non-sale promotion" do
+            let(:promotion) { create(:promotion, apply_automatically: false) }
+
+            it "doesn't connect the promotion to the order" do
+              expect {
+                subject.activate
+              }.to change { order.promotions.count }.by(0)
+            end
+
+            it "doesn't create an adjustment" do
+              expect {
+                subject.activate
+              }.to change { adjustable.adjustments.count }.by(0)
+            end
+          end
+        end
+
+        context "promotion includes item involved" do
+          let!(:rule) { Promotion::Rules::Product.create(products: [line_item.product], promotion: promotion) }
+
+          include_context "creates the adjustment"
+          include_context "creates an order promotion"
+        end
+
+        context "promotion has item total rule" do
+          let(:shirt) { create(:product) }
+          let!(:rule) { Promotion::Rules::ItemTotal.create(preferred_operator: 'gt', preferred_amount: 50, promotion: promotion) }
+
+          before do
+            # Makes the order eligible for this promotion
+            order.item_total = 100
+            order.save
+          end
+
+          include_context "creates the adjustment"
+          include_context "creates an order promotion"
+        end
+      end
+
+      context "activates in Order level" do
+        let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
+        let(:adjustable) { order }
+
+        context "promotion with no rules" do
+          before do
+            # Gives the calculator something to discount
+            order.item_total = 10
+            order.save
+          end
+
+          include_context "creates the adjustment"
+          include_context "creates an order promotion"
+        end
+
+        context "promotion has item total rule" do
+          let(:shirt) { create(:product) }
+          let!(:rule) { Promotion::Rules::ItemTotal.create(preferred_operator: 'gt', preferred_amount: 50, promotion: promotion) }
+
+          before do
+            # Makes the order eligible for this promotion
+            order.item_total = 100
+            order.save
+          end
+
+          include_context "creates the adjustment"
+          include_context "creates an order promotion"
+        end
+      end
+
+      context "activates promotions associated with the order" do
+        let(:promotion) { create :promotion, :with_order_adjustment, code: 'promo' }
+        let(:promotion_code) { promotion.codes.first }
+        let(:adjustable) { order }
+
+        before do
+          Spree::OrderPromotion.create!(promotion: promotion, order: order, promotion_code: promotion_code)
+          order.recalculate
+        end
+
+        include_context "creates the adjustment"
+
+        it "records the promotion code in the adjustment" do
+          subject.activate
+          expect(adjustable.adjustments.map(&:promotion_code)).to eq [promotion_code]
+        end
+
+        it "checks if the promotion code is eligible" do
+          expect_any_instance_of(Spree::Promotion).to receive(:eligible?).at_least(2).times.with(anything, promotion_code: promotion_code).and_return(false)
+          subject.activate
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  module PromotionHandler
+    RSpec.describe Coupon, type: :model do
+      let(:order) { double("Order", coupon_code: "10off").as_null_object }
+
+      subject { Coupon.new(order) }
+
+      def expect_order_connection(order:, promotion:, promotion_code: nil)
+        expect(order.promotions.to_a).to include(promotion)
+        expect(order.order_promotions.flat_map(&:promotion_code)).to include(promotion_code)
+      end
+
+      def expect_adjustment_creation(adjustable:, promotion:, promotion_code: nil)
+        expect(adjustable.adjustments.map(&:source).map(&:promotion)).to include(promotion)
+        expect(adjustable.adjustments.map(&:promotion_code)).to include(promotion_code)
+      end
+
+      it "returns self in apply" do
+        expect(subject.apply).to be_a Coupon
+      end
+
+      context 'status messages' do
+        let(:coupon) { Coupon.new(order) }
+
+        describe "#set_success_code" do
+          let(:status) { :coupon_code_applied }
+          subject { coupon.set_success_code status }
+
+          it 'should have status_code' do
+            subject
+            expect(coupon.status_code).to eq(status)
+          end
+
+          it 'should have success message' do
+            subject
+            expect(coupon.success).to eq(I18n.t(status, scope: 'spree'))
+          end
+        end
+
+        describe "#set_error_code" do
+          let(:status) { :coupon_code_not_found }
+
+          subject { coupon.set_error_code status }
+
+          it 'should have status_code' do
+            subject
+            expect(coupon.status_code).to eq(status)
+          end
+
+          it 'should have error message' do
+            subject
+            expect(coupon.error).to eq(I18n.t(status, scope: 'spree'))
+          end
+        end
+      end
+
+      context "coupon code promotion doesnt exist" do
+        before { create(:promotion) }
+
+        it "doesnt fetch any promotion" do
+          expect(subject.promotion).to be_blank
+        end
+
+        context "with no actions defined" do
+          before { create(:promotion, code: "10off") }
+
+          it "populates error message" do
+            subject.apply
+            expect(subject.error).to eq I18n.t('spree.coupon_code_not_found')
+          end
+        end
+      end
+
+      context "existing coupon code promotion" do
+        let!(:promotion) { promotion_code.promotion }
+        let(:promotion_code) { create(:promotion_code, value: '10off') }
+        let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
+        let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
+
+        it "fetches with given code" do
+          expect(subject.promotion).to eq promotion
+        end
+
+        context "with a per-item adjustment action" do
+          let(:order) { create(:order_with_line_items, line_items_count: 3) }
+
+          context "right coupon given" do
+            context "with correct coupon code casing" do
+              before { order.coupon_code = "10off" }
+
+              it "successfully activates promo" do
+                expect(order.total).to eq(130)
+                subject.apply
+                expect(subject.success).to be_present
+                expect_order_connection(order: order, promotion: promotion, promotion_code: promotion_code)
+                order.line_items.each do |line_item|
+                  expect_adjustment_creation(adjustable: line_item, promotion: promotion, promotion_code: promotion_code)
+                end
+                # Ensure that applying the adjustment actually affects the order's total!
+                expect(order.reload.total).to eq(100)
+              end
+
+              it "coupon already applied to the order" do
+                subject.apply
+                expect(subject.success).to be_present
+                subject.apply
+                expect(subject.error).to eq I18n.t('spree.coupon_code_already_applied')
+              end
+            end
+
+            # Regression test for https://github.com/spree/spree/issues/4211
+            context "with incorrect coupon code casing" do
+              before { order.coupon_code = "10OFF" }
+              it "successfully activates promo" do
+                expect(order.total).to eq(130)
+                subject.apply
+                expect(subject.success).to be_present
+                expect_order_connection(order: order, promotion: promotion, promotion_code: promotion_code)
+                order.line_items.each do |line_item|
+                  expect_adjustment_creation(adjustable: line_item, promotion: promotion, promotion_code: promotion_code)
+                end
+                # Ensure that applying the adjustment actually affects the order's total!
+                expect(order.reload.total).to eq(100)
+              end
+            end
+          end
+
+          context "coexists with a non coupon code promo" do
+            let!(:order) { create(:order) }
+
+            before do
+              order.coupon_code = "10off"
+              calculator = Calculator::FlatRate.new(preferred_amount: 10)
+              general_promo = create(:promotion, apply_automatically: true, name: "General Promo")
+              Promotion::Actions::CreateItemAdjustments.create(promotion: general_promo, calculator: calculator)
+
+              order.contents.add create(:variant)
+            end
+
+            # regression spec for https://github.com/spree/spree/issues/4515
+            it "successfully activates promo" do
+              subject.apply
+              expect(subject).to be_successful
+              expect_order_connection(order: order, promotion: promotion, promotion_code: promotion_code)
+              order.line_items.each do |line_item|
+                expect_adjustment_creation(adjustable: line_item, promotion: promotion, promotion_code: promotion_code)
+              end
+            end
+          end
+
+          context "applied alongside another valid promotion " do
+            let!(:order) { Order.create }
+
+            before do
+              order.coupon_code = "10off"
+              calculator = Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10)
+              general_promo = create(:promotion, apply_automatically: true, name: "General Promo")
+              Promotion::Actions::CreateItemAdjustments.create!(promotion: general_promo, calculator: calculator)
+
+              order.contents.add create(:variant, price: 500)
+              order.contents.add create(:variant, price: 10)
+
+              Spree::PromotionHandler::Cart.new(order).activate
+            end
+
+            it "successfully activates both promotions and returns success" do
+              subject.apply
+              expect(subject).to be_successful
+              order.line_items.each do |line_item|
+                expect(line_item.adjustments.count).to eq 2
+                expect_adjustment_creation(adjustable: line_item, promotion: promotion, promotion_code: promotion_code)
+              end
+            end
+          end
+        end
+
+        context "with a free-shipping adjustment action" do
+          let!(:action) { Promotion::Actions::FreeShipping.create!(promotion: promotion) }
+          context "right coupon code given" do
+            let(:order) { create(:order_with_line_items, line_items_count: 3) }
+
+            before { order.coupon_code = "10off" }
+
+            it "successfully activates promo" do
+              expect(order.total).to eq(130)
+              subject.apply
+              expect(subject.success).to be_present
+
+              expect_order_connection(order: order, promotion: promotion, promotion_code: promotion_code)
+              order.shipments.each do |shipment|
+                expect_adjustment_creation(adjustable: shipment, promotion: promotion, promotion_code: promotion_code)
+              end
+            end
+
+            it "coupon already applied to the order" do
+              subject.apply
+              expect(subject.success).to be_present
+              subject.apply
+              expect(subject.error).to eq I18n.t('spree.coupon_code_already_applied')
+            end
+          end
+        end
+
+        context "with a whole-order adjustment action" do
+          let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
+          context "right coupon given" do
+            let(:order) { create(:order) }
+            let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
+
+            before do
+              allow(order).to receive_messages({
+                coupon_code: "10off",
+                # These need to be here so that promotion adjustment "wins"
+                item_total: 50,
+                ship_total: 10
+              })
+            end
+
+            it "successfully activates promo" do
+              subject.apply
+              expect(subject.success).to be_present
+              expect(order.adjustments.count).to eq(1)
+              expect_order_connection(order: order, promotion: promotion, promotion_code: promotion_code)
+              expect_adjustment_creation(adjustable: order, promotion: promotion, promotion_code: promotion_code)
+            end
+
+            context "when the coupon is already applied to the order" do
+              before { subject.apply }
+
+              it "is not successful" do
+                subject.apply
+                expect(subject.successful?).to be false
+              end
+
+              it "returns a coupon has already been applied error" do
+                subject.apply
+                expect(subject.error).to eq I18n.t('spree.coupon_code_already_applied')
+              end
+            end
+
+            context "when the coupon fails to activate" do
+              before { allow_any_instance_of(Spree::Promotion).to receive(:activate).and_return false }
+
+              it "is not successful" do
+                subject.apply
+                expect(subject.successful?).to be false
+              end
+
+              it "returns a coupon failed to activate error" do
+                subject.apply
+                expect(subject.error).to eq I18n.t('spree.coupon_code_unknown_error')
+              end
+            end
+
+            context "when the promotion exceeds its usage limit" do
+              let!(:second_order) { FactoryBot.create(:completed_order_with_promotion, promotion: promotion) }
+
+              before do
+                promotion.update!(usage_limit: 1)
+                Coupon.new(second_order).apply
+              end
+
+              it "is not successful" do
+                subject.apply
+                expect(subject.successful?).to be false
+              end
+
+              it "returns a coupon is at max usage error" do
+                subject.apply
+                expect(subject.error).to eq I18n.t('spree.coupon_code_max_usage')
+              end
+            end
+          end
+        end
+
+        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_categories: [tax_category], zone: zone ) }
+
+          before(:each) do
+            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
+              order.coupon_code = "10off"
+
+              3.times do |_i|
+                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)
+              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)
+            end
+          end
+
+          context "and the product price is greater than promo discount" do
+            before(:each) do
+              order.coupon_code = "10off"
+
+              3.times do |_i|
+                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)
+              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)
+            end
+          end
+
+          context "and multiple quantity per line item" do
+            before(:each) do
+              twnty_off = create(:promotion, name: "promo", code: "20off")
+              twnty_off_calc = Calculator::FlatRate.new(preferred_amount: 20)
+              Promotion::Actions::CreateItemAdjustments.create(promotion: twnty_off,
+                                                               calculator: twnty_off_calc)
+
+              order.coupon_code = "20off"
+
+              3.times do |_i|
+                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)
+              coupon.apply
+              expect(coupon.success).to be_present
+              # 0
+              expect(order.reload.total).to eq(0)
+              expect(order.additional_tax_total).to eq(0)
+            end
+          end
+        end
+      end
+    end
+  end
+end