solidus_core_devise_token_auth 2.8.0.alpha.0

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

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

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

@@ -0,0 +1,72 @@
+# 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_attributes(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_attributes(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

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

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

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