solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,174 @@
+# 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
+      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
+      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
+      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' }
+
+    before do
+      rule.preferred_match_policy = 'invalid'
+      rule.save!(validate: false)
+      line_item.product.taxons << taxon
+      rule.taxons << taxon
+    end
+
+    context 'with an invalid match policy' do
+      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
+  end
+end

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

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

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

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

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

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

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

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

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