solidus_core 2.10.2 → 2.11.3

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::UserLoggedIn, type: :model do
-  let(:rule) { Spree::Promotion::Rules::UserLoggedIn.new }
-
-  context "#eligible?(order)" do
-    let(:order) { Spree::Order.new }
-
-    it "should be eligible if order has an associated user" do
-      user = double('User')
-      allow(order).to receive_messages(user: user)
-
-      expect(rule).to be_eligible(order)
-    end
-
-    context "when user is not logged in" do
-      before { allow(order).to receive_messages(user: nil) } # better to be explicit here
-      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 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

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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/rules/user_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::User, type: :model do
-  let(:rule) { Spree::Promotion::Rules::User.new }
-
-  context "#eligible?(order)" do
-    let(:order) { Spree::Order.new }
-
-    it "should not be eligible if users are not provided" do
-      expect(rule).not_to be_eligible(order)
-    end
-
-    it "should be eligible if users include user placing the order" do
-      user = mock_model(Spree::LegacyUser)
-      users = [user, mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(users: users)
-      allow(order).to receive_messages(user: user)
-
-      expect(rule).to be_eligible(order)
-    end
-
-    it "should not be eligible if user placing the order is not listed" do
-      allow(order).to receive_messages(user: mock_model(Spree::LegacyUser))
-      users = [mock_model(Spree::LegacyUser), mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(users: users)
-
-      expect(rule).not_to be_eligible(order)
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/3885
-    it "can assign to user_ids" do
-      user1 = Spree::LegacyUser.create!(email: "test1@example.com")
-      user2 = Spree::LegacyUser.create!(email: "test2@example.com")
-      rule.user_ids = "#{user1.id}, #{user2.id}"
-    end
-  end
-end

data/spec/models/spree/promotion_action_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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 "generates its own partial path" do
-      expect(action.to_partial_path).to eq 'spree/admin/promotions/actions/my_promotion_action'
-    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_category_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PromotionCategory, type: :model do
-  describe 'validation' do
-    let(:name) { 'Nom' }
-    subject { Spree::PromotionCategory.new name: name }
-
-    context 'when all required attributes are specified' do
-      it { is_expected.to be_valid }
-    end
-
-    context 'when name is missing' do
-      let(:name) { nil }
-      it { is_expected.not_to be_valid }
-    end
-  end
-end

data/spec/models/spree/promotion_code/batch_builder_spec.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Spree::PromotionCode::BatchBuilder do
-  let(:promotion) { create(:promotion) }
-  let(:base_code) { "abc" }
-  let(:options) { {} }
-  let(:number_of_codes) { 10 }
-  let(:promotion_code_batch) do
-    Spree::PromotionCodeBatch.create!(
-      promotion_id: promotion.id,
-      base_code: base_code,
-      number_of_codes: number_of_codes,
-      email: "test@email.com"
-    )
-  end
-
-  subject { described_class.new(promotion_code_batch, options) }
-
-  describe "#build_promotion_codes" do
-    context "with a failed build" do
-      before do
-        allow(subject).to receive(:generate_random_codes).and_raise "Error"
-
-        expect { subject.build_promotion_codes }.to raise_error RuntimeError
-      end
-
-      it "updates the error and state on promotion batch" do
-        expect(promotion_code_batch.reload.error).to eq("#<RuntimeError: Error>")
-        expect(promotion_code_batch.reload.state).to eq("failed")
-      end
-    end
-
-    context "with a successful build" do
-      before do
-        allow(Spree::PromotionCodeBatchMailer)
-          .to receive(:promotion_code_batch_finished)
-          .and_call_original
-
-        subject.build_promotion_codes
-      end
-
-      it "update the promotion codes count for the batch" do
-        expect(promotion_code_batch.promotion_codes.count).to eq(10)
-      end
-
-      it "builds the correct number of codes" do
-        expect(subject.promotion.codes.size).to eq(10)
-      end
-
-      it "builds codes with distinct values" do
-        expect(subject.promotion.codes.map(&:value).uniq.size).to eq(10)
-      end
-
-      it "updates the promotion code batch state to completed" do
-        expect(promotion_code_batch.state).to eq("completed")
-      end
-    end
-
-    context "with likely code contention" do
-      let(:number_of_codes) { 50 }
-      let(:options) do
-        {
-          batch_size: 10,
-          sample_characters: (0..9).to_a.map(&:to_s),
-          random_code_length: 2
-        }
-      end
-
-      it "creates the correct number of codes" do
-        subject.build_promotion_codes
-        expect(promotion.codes.size).to eq(number_of_codes)
-      end
-    end
-  end
-
-  describe "#join_character" do
-    context "with the default join charachter _" do
-      it "builds codes with the same base prefix" do
-        subject.build_promotion_codes
-
-        values = subject.promotion.codes.map(&:value)
-        expect(values.all? { |val| val.starts_with?("#{base_code}_") }).to be true
-      end
-    end
-
-    context "with a custom join separator" do
-      let(:promotion_code_batch) do
-        Spree::PromotionCodeBatch.create!(
-          promotion_id: promotion.id,
-          base_code: base_code,
-          number_of_codes: number_of_codes,
-          email: "test@email.com",
-          join_characters: "x"
-        )
-      end
-
-      it "builds codes with the same base prefix" do
-        subject.build_promotion_codes
-
-        values = subject.promotion.codes.map(&:value)
-        expect(values.all? { |val| val.starts_with?("#{base_code}x") }).to be true
-      end
-    end
-  end
-end

data/spec/models/spree/promotion_code_batch_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Spree::PromotionCodeBatch, type: :model do
-  subject do
-    described_class.create!(
-      promotion_id: create(:promotion).id,
-      base_code: "abc",
-      number_of_codes: 1,
-      error: nil,
-      email: "test@email.com"
-    )
-  end
-
-  describe "#process" do
-    context "with a pending code batch" do
-      it "should call the worker" do
-        expect { subject.process }
-          .to have_enqueued_job(Spree::PromotionCodeBatchJob)
-      end
-
-      it "should update the state to processing" do
-        subject.process
-
-        expect(subject.state).to eq("processing")
-      end
-    end
-
-    context "with a processing batch" do
-      before { subject.update_attribute(:state, "processing") }
-
-      it "should raise an error" do
-        expect{ subject.process }.to raise_error Spree::PromotionCodeBatch::CantProcessStartedBatch
-      end
-    end
-
-    context "with a completed batch" do
-      before { subject.update_attribute(:state, "completed") }
-
-      it "should raise an error" do
-        expect{ subject.process }.to raise_error Spree::PromotionCodeBatch::CantProcessStartedBatch
-      end
-    end
-
-    context "with a failed batch" do
-      before { subject.update_attribute(:state, "failed") }
-
-      it "should raise an error" do
-        expect{ subject.process }.to raise_error Spree::PromotionCodeBatch::CantProcessStartedBatch
-      end
-    end
-  end
-end

data/spec/models/spree/promotion_code_spec.rb

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