spree_core 3.1.14 → 3.2.0.rc1

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+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
+      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
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+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 { should be true }
+    end
+    context "when promotable is not an order" do
+      let(:promotable) { Spree::LineItem.new }
+      it { should 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[variant.product.id => [
+          variant.option_values.pluck(:id).first
+        ]]
+      end
+      it { should be true }
+    end
+    context "when there are no applicable line items" do
+      before do
+        rule.preferred_eligible_values = Hash[99 => [99]]
+      end
+      it { should 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 { should be true }
+      end
+      context "when not all of the option values match" do
+        let(:option_value_ids) { [option_value_blue.id, option_value_medium.id] }
+        it { should 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 { should be false }
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+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
+      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
+      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
+      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 { should be_truthy }
+      end
+
+      context 'for product not in rule' do
+        let(:line_item) { other_line_item }
+        it { should 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 { should be_truthy }
+      end
+
+      context 'for product not in rule' do
+        let(:line_item) { other_line_item }
+        it { should 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 { should be_falsey }
+      end
+
+      context 'for product not in rule' do
+        let(:line_item) { other_line_item }
+        it { should be_truthy }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Rules::Taxon, type: :model do
+  let(:rule){ subject }
+
+  context '#elegible?(order)' do
+    let(:taxon){ create :taxon, name: 'first' }
+    let(:taxon2){ create :taxon, name: 'second'}
+    let(:order){ create :order_with_line_items }
+
+    before do
+      rule.save
+    end
+
+    context 'with any match policy' do
+      before do
+        rule.preferred_match_policy = 'any'
+      end
+
+      it 'is eligible if order does has any prefered taxon' do
+        order.products.first.taxons << taxon
+        rule.taxons << taxon
+        expect(rule).to be_eligible(order)
+      end
+
+      context 'when order contains items from different taxons' do
+        before do
+          order.products.first.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
+      end
+
+      context 'when a product has a taxon child of a taxon rule' do
+        before do
+          taxon.children << taxon2
+          order.products.first.taxons << taxon2
+          rule.taxons << taxon2
+        end
+
+        it{ expect(rule).to be_eligible(order) }
+      end
+    end
+
+    context 'with all match policy' do
+      before do
+        rule.preferred_match_policy = 'all'
+      end
+
+      it 'is eligible order has all prefered taxons' do
+        order.products.first.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
+      end
+
+      context 'when a product has a taxon child of a taxon rule' do
+        let(:taxon3){ create :taxon }
+
+        before do
+          taxon.children << taxon2
+          order.products.first.taxons << taxon2
+          order.products.last.taxons << taxon3
+          rule.taxons << taxon2
+          rule.taxons << taxon3
+        end
+
+        it{ expect(rule).to be_eligible(order) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+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
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Rules::User, type: :model do
+  let(:rule) { Spree::Promotion::Rules::User.new }
+  let(:test_user) { create :user }
+
+  describe 'Associations' do
+    it 'should have many promotion_rule_users' do
+      is_expected.to have_many(:promotion_rule_users).with_foreign_key(:promotion_rule_id).
+        class_name('Spree::PromotionRuleUser').dependent(:destroy)
+    end
+  end
+
+  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 #3885
+    it "can assign to user_ids" do
+      user1 = Spree::LegacyUser.create!(email: "test1@example.com")
+      user2 = Spree::LegacyUser.create!(email: "test2@example.com")
+      expect { rule.user_ids = "#{user1.id}, #{user2.id}" }.not_to raise_error
+    end
+  end
+end

data/spec/models/spree/promotion_action_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Spree::PromotionAction, type: :model do
+
+  it "should force developer to implement 'perform' method" do
+    expect { MyAction.new.perform }.to raise_error(NameError)
+  end
+
+end
+

data/spec/models/spree/promotion_category_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+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_handler/cart_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Spree
+  module PromotionHandler
+    describe Cart, type: :model do
+      let(:line_item) { create(:line_item) }
+      let(:order) { line_item.order }
+
+      let(:promotion) { Promotion.create(name: "At line items") }
+      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
+
+      subject { Cart.new(order, line_item) }
+
+      context "activates in LineItem level" do
+        let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
+        let(:adjustable) { 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
+
+        context "promotion with no rules" do
+          include_context "creates the adjustment"
+        end
+
+        context "promotion includes item involved" do
+          let!(:rule) { Promotion::Rules::Product.create(products: [line_item.product], promotion: promotion) }
+
+          include_context "creates the adjustment"
+        end
+
+        context "promotion has item total rule" do
+          let(:shirt) { create(:product) }
+          let!(:rule) { Promotion::Rules::ItemTotal.create(preferred_operator_min: 'gt', preferred_amount_min: 50, preferred_operator_max: 'lt', preferred_amount_max: 150, promotion: promotion) }
+
+          before do
+            # Makes the order eligible for this promotion
+            order.item_total = 100
+            order.save
+          end
+
+          include_context "creates the adjustment"
+        end
+      end
+
+      context "activates in Order level" do
+        let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
+        let(:adjustable) { order }
+
+        shared_context "creates the adjustment" do
+          it "creates the adjustment" do
+            expect {
+              subject.activate
+            }.to change { adjustable.adjustments.count }.by(1)
+          end
+        end
+
+        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"
+        end
+
+        context "promotion has item total rule" do
+          let(:shirt) { create(:product) }
+          let!(:rule) { Promotion::Rules::ItemTotal.create(preferred_operator_min: 'gt', preferred_amount_min: 50, preferred_operator_max: 'lt', preferred_amount_max: 150, promotion: promotion) }
+
+          before do
+            # Makes the order eligible for this promotion
+            order.item_total = 100
+            order.save
+          end
+
+          include_context "creates the adjustment"
+        end
+      end
+
+      context "activates promotions associated with the order" do
+        let(:promo) { create :promotion_with_item_adjustment, adjustment_rate: 5, code: 'promo' }
+        let(:adjustable) { line_item }
+
+        before do
+          order.promotions << promo
+        end
+
+        it "creates the adjustment" do
+          expect {
+            subject.activate
+          }.to change { adjustable.adjustments.count }.by(1)
+        end
+      end
+    end
+  end
+end