solidus_core 2.10.0 → 2.11.0

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

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::Taxon, type: :model do
-  let(:taxon)   { create :taxon, name: 'first' }
-  let(:taxon2)  { create :taxon, name: 'second' }
-  let(:order)   { create :order_with_line_items }
-  let(:product) { order.products.first }
-
-  let(:rule) do
-    Spree::Promotion::Rules::Taxon.create!(promotion: create(:promotion))
-  end
-
-  context '#eligible?(order)' do
-    context 'with any match policy' do
-      before do
-        rule.update!(preferred_match_policy: 'any')
-      end
-
-      it 'is eligible if order does have any prefered taxon' do
-        product.taxons << taxon
-        rule.taxons << taxon
-        expect(rule).to be_eligible(order)
-      end
-
-      context 'when order contains items from different taxons' do
-        before do
-          product.taxons << taxon
-          rule.taxons << taxon
-        end
-
-        it 'should act on a product within the eligible taxon' do
-          expect(rule).to be_actionable(order.line_items.last)
-        end
-
-        it 'should not act on a product in another taxon' do
-          order.line_items << create(:line_item, product: create(:product, taxons: [taxon2]))
-          expect(rule).not_to be_actionable(order.line_items.last)
-        end
-      end
-
-      context "when order does not have any prefered taxon" do
-        before { rule.taxons << taxon2 }
-        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 add a product from an applicable category 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_matching_taxons
-        end
-      end
-
-      context 'when a product has a taxon child of a taxon rule' do
-        before do
-          taxon.children << taxon2
-          product.taxons << taxon2
-          rule.taxons << taxon
-        end
-
-        it{ expect(rule).to be_eligible(order) }
-      end
-    end
-
-    context 'with all match policy' do
-      before do
-        rule.update!(preferred_match_policy: 'all')
-      end
-
-      it 'is eligible order has all prefered taxons' do
-        product.taxons << taxon2
-        order.products.last.taxons << taxon
-
-        rule.taxons = [taxon, taxon2]
-
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when order does not have all prefered taxons" do
-        before { rule.taxons << taxon }
-        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 add a product from all applicable categories 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 :missing_taxon
-        end
-      end
-
-      context 'when a product has a taxon child of a taxon rule' do
-        let(:taxon3) { create :taxon }
-
-        before do
-          taxon.children << taxon2
-          taxon.save!
-          product.taxons = [taxon2, taxon3]
-          rule.taxons = [taxon, taxon3]
-        end
-
-        it { expect(rule).to be_eligible(order) }
-      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
-        it "sets an error code" do
-          rule.eligible?(order)
-          expect(rule.eligibility_errors.details[:base].first[:error_code]).
-            to eq :has_excluded_taxon
-        end
-      end
-    end
-
-    context 'with an invalid match policy' do
-      before do
-        order.products.first.taxons << taxon
-        rule.taxons << taxon
-        rule.preferred_match_policy = 'invalid'
-        rule.save!(validate: false)
-      end
-
-      it 'logs a warning and uses "any" policy' do
-        expect(Spree::Deprecation).to(
-          receive(:warn).
-          with(/has unexpected match policy "invalid"/)
-        )
-
-        expect(
-          rule.eligible?(order)
-        ).to be_truthy
-      end
-    end
-  end
-
-  describe '#actionable?' do
-    let(:line_item) { order.line_items.first! }
-    let(:order) { create :order_with_line_items }
-    let(:taxon) { create :taxon, name: 'first' }
-
-    context 'with an invalid match policy' do
-      before do
-        rule.preferred_match_policy = 'invalid'
-        rule.save!(validate: false)
-        line_item.product.taxons << taxon
-        rule.taxons << taxon
-      end
-
-      it 'logs a warning and uses "any" policy' do
-        expect(Spree::Deprecation).to(
-          receive(:warn).
-          with(/has unexpected match policy "invalid"/)
-        )
-
-        expect(
-          rule.actionable?(line_item)
-        ).to be_truthy
-      end
-    end
-
-    context 'when a product has a taxon of a taxon rule' do
-      before do
-        product.taxons << taxon
-        rule.taxons << taxon
-        rule.save!
-      end
-
-      it 'is actionable' do
-        expect(rule).to be_actionable(line_item)
-      end
-    end
-
-    context 'when a product has a taxon child of a taxon rule' do
-      before do
-        taxon.children << taxon2
-        product.taxons << taxon2
-        rule.taxons << taxon
-        rule.save!
-      end
-
-      it 'is actionable' do
-        expect(rule).to be_actionable(line_item)
-      end
-    end
-
-    context 'when a product does not have taxon or child taxon of a taxon rule' do
-      before do
-        product.taxons << taxon2
-        rule.taxons << taxon
-        rule.save!
-      end
-
-      it 'is not actionable' do
-        expect(rule).not_to be_actionable(line_item)
-      end
-    end
-  end
-end

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