solidus_core 2.10.2 → 2.11.3

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

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

@@ -1,87 +0,0 @@
-# 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).to be_eligible(order) }
-    it "does not set an error message" do
-      rule.eligible?(order)
-      expect(rule.eligibility_errors.full_messages.first).
-        to be_nil
-    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
-          it "sets an error code" do
-            rule.eligible?(order)
-            expect(rule.eligibility_errors.details[:base].first[:error_code]).
-              to eq :not_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
-        it "sets an error code" do
-          rule.eligible?(order)
-          expect(rule.eligibility_errors.details[:base].first[:error_code]).
-            to eq :not_first_order
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# 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(completed_at: order_completion_date_1)
-
-          old_order_2 = create :completed_order_with_totals, user: user
-          old_order_2.update(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

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

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::ItemTotal, type: :model do
-  let(:rule) do
-    Spree::Promotion::Rules::ItemTotal.new(
-      preferred_amount: preferred_amount,
-      preferred_operator: preferred_operator
-    )
-  end
-  let(:order) { double(:order, item_total: item_total, currency: order_currency) }
-  let(:preferred_amount) { 50 }
-  let(:order_currency) { 'USD' }
-
-  context "preferred operator set to gt" do
-    let(:preferred_operator) { 'gt' }
-
-    context "item total is greater than preferred amount" do
-      let(:item_total) { 51 }
-
-      it "should be eligible when item total is greater than preferred amount" do
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when the order is a different currency" do
-        let(:order_currency) { "CAD" }
-
-        it "is not eligible" do
-          expect(rule).not_to be_eligible(order)
-        end
-      end
-    end
-
-    context "when item total is equal to preferred amount" do
-      let(:item_total) { 50 }
-
-      it "is not eligible" do
-        expect(rule).not_to 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
-      it "sets an error code" do
-        rule.eligible?(order)
-        expect(rule.eligibility_errors.details[:base].first[:error_code]).
-          to eq :item_total_less_than_or_equal
-      end
-    end
-
-    context "when item total is lower than preferred amount" do
-      let(:item_total) { 49 }
-
-      it "is not eligible" do
-        expect(rule).not_to 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
-      it "sets an error code" do
-        rule.eligible?(order)
-        expect(rule.eligibility_errors.details[:base].first[:error_code]).
-          to eq :item_total_less_than_or_equal
-      end
-    end
-  end
-
-  context "preferred operator set to gte" do
-    let(:preferred_operator) { 'gte' }
-
-    context "total is greater than preferred amount" do
-      let(:item_total) { 51 }
-
-      it "should be eligible when item total is greater than preferred amount" do
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when the order is a different currency" do
-        let(:order_currency) { "CAD" }
-
-        it "is not eligible" do
-          expect(rule).not_to be_eligible(order)
-        end
-      end
-    end
-
-    context "item total is equal to preferred amount" do
-      let(:item_total) { 50 }
-
-      it "should be eligible" do
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when the order is a different currency" do
-        let(:order_currency) { "CAD" }
-
-        it "is not eligible" do
-          expect(rule).not_to be_eligible(order)
-        end
-      end
-    end
-
-    context "when item total is lower than preferred amount" do
-      let(:item_total) { 49 }
-
-      it "is not eligible" do
-        expect(rule).not_to 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
-      it "sets an error code" do
-        rule.eligible?(order)
-        expect(rule.eligibility_errors.details[:base].first[:error_code]).
-          to eq :item_total_less_than
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::NthOrder 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) { "not an order" }
-
-      it { is_expected.to be false }
-    end
-  end
-
-  describe "eligible?" do
-    let(:instance) { described_class.new }
-    subject { instance.eligible?(order) }
-
-    before do
-      instance.preferred_nth_order = 2
-    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
-        before do
-          old_order = create :completed_order_with_totals, user: user
-          old_order.update(completed_at: 1.day.ago)
-        end
-
-        context "when this order will be the 'nth' order" do
-          it { is_expected.to be true }
-        end
-
-        context "when this order is completed and is still the 'nth' order" do
-          before do
-            order.update(completed_at: Time.current)
-          end
-
-          it { is_expected.to be true }
-        end
-
-        context "when this order will not be the 'nth' order" do
-          before do
-            instance.preferred_nth_order = 100
-          end
-
-          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

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::OneUsePerUser, type: :model do
-  let(:rule) { described_class.new }
-
-  describe '#eligible?(order)' do
-    subject { rule.eligible?(order) }
-    let(:order) { double Spree::Order, user: user }
-    let(:user) { double Spree::LegacyUser }
-    let(:promotion) { stub_model Spree::Promotion, used_by?: used_by }
-    let(:used_by) { false }
-
-    before { rule.promotion = promotion }
-
-    context 'when the order is assigned to a user' do
-      context 'when the user has used this promotion before' do
-        let(:used_by) { true }
-
-        it { is_expected.to be false }
-        it "sets an error message" do
-          subject
-          expect(rule.eligibility_errors.full_messages.first).
-            to eq "This coupon code can only be used once per user."
-        end
-        it "sets an error code" do
-          rule.eligible?(order)
-          expect(rule.eligibility_errors.details[:base].first[:error_code]).
-            to eq :limit_once_per_user
-        end
-      end
-
-      context 'when the user has not used this promotion before' do
-        it { is_expected.to be true }
-      end
-    end
-
-    context 'when the order is not assigned to a user' do
-      let(:user) { nil }
-      it { is_expected.to be false }
-      it "sets an error message" do
-        subject
-        expect(rule.eligibility_errors.full_messages.first).
-          to eq "You need to login before applying this coupon code."
-      end
-      it "sets an error code" do
-        rule.eligible?(order)
-        expect(rule.eligibility_errors.details[:base].first[:error_code]).
-          to eq :no_user_specified
-      end
-    end
-  end
-end