solidus_core 2.10.1 → 2.11.2

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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::OptionValue do
-  let(:rule) { Spree::Promotion::Rules::OptionValue.new }
-
-  describe "#preferred_eligible_values" do
-    subject { rule.preferred_eligible_values }
-    it "assigns a nicely formatted hash" do
-      rule.preferred_eligible_values = Hash["5" => "1,2", "6" => "1"]
-      expect(subject).to eq Hash[5 => [1, 2], 6 => [1]]
-    end
-  end
-
-  describe "#applicable?" do
-    subject { rule.applicable?(promotable) }
-    context "when promotable is an order" do
-      let(:promotable) { Spree::Order.new }
-      it { is_expected.to be true }
-    end
-    context "when promotable is not an order" do
-      let(:promotable) { Spree::LineItem.new }
-      it { is_expected.to be false }
-    end
-  end
-
-  describe "#eligible?" do
-    let(:variant) { create :variant }
-    let(:line_item) { create :line_item, variant: variant }
-    let(:promotable) { line_item.order }
-    subject { rule.eligible?(promotable) }
-    context "when there are any applicable line items" do
-      before do
-        rule.preferred_eligible_values = Hash[line_item.product.id => [
-          line_item.variant.option_values.pluck(:id).first
-        ]]
-      end
-      it { is_expected.to be true }
-    end
-    context "when there are no applicable line items" do
-      before do
-        rule.preferred_eligible_values = Hash[99 => [99]]
-      end
-      it { is_expected.to be false }
-    end
-  end
-
-  describe "#actionable?" do
-    let(:line_item) { create :line_item }
-    let(:option_value_blue) do
-      create(
-        :option_value,
-        name: 'Blue',
-        presentation: 'Blue',
-        option_type: create(
-          :option_type,
-          name: 'foo-colour',
-          presentation: 'Colour'
-        )
-      )
-    end
-    let(:option_value_medium) do
-      create(
-        :option_value,
-        name: 'Medium',
-        presentation: 'M'
-      )
-    end
-    before do
-      line_item.variant.option_values << option_value_blue
-      rule.preferred_eligible_values = Hash[product_id => option_value_ids]
-    end
-    subject { rule.actionable?(line_item) }
-    context "when the line item has the correct product" do
-      let(:product_id) { line_item.product.id }
-      context "when all of the option values match" do
-        let(:option_value_ids) { [option_value_blue.id] }
-        it { is_expected.to be true }
-      end
-      context "when any of the option values match" do
-        let(:option_value_ids) { [option_value_blue.id, option_value_medium.id] }
-        it { is_expected.to be true }
-      end
-      context "when none of the option values match" do
-        let(:option_value_ids) { [option_value_medium.id] }
-        it { is_expected.to be false }
-      end
-    end
-    context "when the line item's product doesn't match" do
-      let(:product_id) { 99 }
-      let(:option_value_ids) { [99] }
-      it { is_expected.to be false }
-    end
-  end
-end

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

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Promotion::Rules::Product, type: :model do
-  let(:rule) { Spree::Promotion::Rules::Product.new(rule_options) }
-  let(:rule_options) { {} }
-
-  context "#eligible?(order)" do
-    let(:order) { Spree::Order.new }
-
-    it "should be eligible if there are no products" do
-      allow(rule).to receive_messages(eligible_products: [])
-      expect(rule).to be_eligible(order)
-    end
-
-    before do
-      3.times { |i| instance_variable_set("@product#{i}", mock_model(Spree::Product)) }
-    end
-
-    context "with 'any' match policy" do
-      let(:rule_options) { super().merge(preferred_match_policy: 'any') }
-
-      it "should be eligible if any of the products is in eligible products" do
-        allow(order).to receive_messages(products: [@product1, @product2])
-        allow(rule).to receive_messages(eligible_products: [@product2, @product3])
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when none of the products are eligible products" do
-        before do
-          allow(order).to receive_messages(products: [@product1])
-          allow(rule).to receive_messages(eligible_products: [@product2, @product3])
-        end
-        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 an applicable product 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_applicable_products
-        end
-      end
-    end
-
-    context "with 'all' match policy" do
-      let(:rule_options) { super().merge(preferred_match_policy: 'all') }
-
-      it "should be eligible if all of the eligible products are ordered" do
-        allow(order).to receive_messages(products: [@product3, @product2, @product1])
-        allow(rule).to receive_messages(eligible_products: [@product2, @product3])
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when any of the eligible products is not ordered" do
-        before do
-          allow(order).to receive_messages(products: [@product1, @product2])
-          allow(rule).to receive_messages(eligible_products: [@product1, @product2, @product3])
-        end
-        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't be applied because you don't have all of the necessary products in your cart."
-        end
-        it "sets an error code" do
-          rule.eligible?(order)
-          expect(rule.eligibility_errors.details[:base].first[:error_code]).
-            to eq :missing_product
-        end
-      end
-    end
-
-    context "with 'none' match policy" do
-      let(:rule_options) { super().merge(preferred_match_policy: 'none') }
-
-      it "should be eligible if none of the order's products are in eligible products" do
-        allow(order).to receive_messages(products: [@product1])
-        allow(rule).to receive_messages(eligible_products: [@product2, @product3])
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when any of the order's products are in eligible products" do
-        before do
-          allow(order).to receive_messages(products: [@product1, @product2])
-          allow(rule).to receive_messages(eligible_products: [@product2, @product3])
-        end
-        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 "Your cart contains a product 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_product
-        end
-      end
-    end
-
-    context "with an invalid match policy" do
-      let(:rule) do
-        Spree::Promotion::Rules::Product.create!(
-          promotion: create(:promotion),
-          product_promotion_rules: [
-            Spree::ProductPromotionRule.new(product: product),
-          ],
-        ).tap do |rule|
-          rule.preferred_match_policy = 'invalid'
-          rule.save!(validate: false)
-        end
-      end
-      let(:product) { order.line_items.first!.product }
-      let(:order) { create(:order_with_line_items, line_items_count: 1) }
-
-      it 'raises' do
-        expect {
-          rule.eligible?(order)
-        }.to raise_error('unexpected match policy: "invalid"')
-      end
-    end
-  end
-
-  describe '#actionable?' do
-    subject do
-      rule.actionable?(line_item)
-    end
-
-    let(:rule_line_item) { Spree::LineItem.new(product: rule_product) }
-    let(:other_line_item) { Spree::LineItem.new(product: other_product) }
-
-    let(:rule_options) { super().merge(products: [rule_product]) }
-    let(:rule_product) { mock_model(Spree::Product) }
-    let(:other_product) { mock_model(Spree::Product) }
-
-    context "with 'any' match policy" do
-      let(:rule_options) { super().merge(preferred_match_policy: 'any') }
-
-      context 'for product in rule' do
-        let(:line_item) { rule_line_item }
-        it { is_expected.to be_truthy }
-      end
-
-      context 'for product not in rule' do
-        let(:line_item) { other_line_item }
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    context "with 'all' match policy" do
-      let(:rule_options) { super().merge(preferred_match_policy: 'all') }
-
-      context 'for product in rule' do
-        let(:line_item) { rule_line_item }
-        it { is_expected.to be_truthy }
-      end
-
-      context 'for product not in rule' do
-        let(:line_item) { other_line_item }
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    context "with 'none' match policy" do
-      let(:rule_options) { super().merge(preferred_match_policy: 'none') }
-
-      context 'for product in rule' do
-        let(:line_item) { rule_line_item }
-        it { is_expected.to be_falsey }
-      end
-
-      context 'for product not in rule' do
-        let(:line_item) { other_line_item }
-        it { is_expected.to be_truthy }
-      end
-    end
-
-    context 'with an invalid match policy' do
-      let(:rule_options) { super().merge(preferred_match_policy: 'invalid') }
-      let(:line_item) { rule_line_item }
-
-      it 'raises' do
-        expect {
-          rule.actionable?(line_item)
-        }.to raise_error('unexpected match policy: "invalid"')
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Spree::Promotion::Rules::Store, type: :model do
-  let(:rule) { described_class.new }
-
-  context "#eligible?(order)" do
-    let(:order) { Spree::Order.new }
-
-    it "is eligible if no stores are provided" do
-      expect(rule).to be_eligible(order)
-    end
-
-    it "is eligible if stores include the order's store" do
-      default_store = Spree::Store.new(name: "Default")
-      other_store = Spree::Store.new(name: "Other")
-
-      rule.stores = [default_store, other_store]
-      order.store = default_store
-
-      expect(rule).to be_eligible(order)
-    end
-
-    it "is not eligible if order is placed in a different store" do
-      default_store = Spree::Store.new(name: "Default")
-      other_store = Spree::Store.new(name: "Other")
-
-      rule.stores = [other_store]
-      order.store = default_store
-
-      expect(rule).not_to be_eligible(order)
-    end
-  end
-end

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