solidus_core 1.1.0 → 1.1.1

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) { Spree::Promotion::Rules::Taxon.create!(promotion: create(:promotion)) }
+
+  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 have 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,37 @@
+require 'spec_helper'
+
+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 #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_builder_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Spree::PromotionBuilder do
+  let(:promotion) { build(:promotion) }
+  let(:base_code) { 'abc' }
+  let(:number_of_codes) { 1 }
+  let(:promotion_attrs) { { name: 'some promo' } }
+  let(:builder) { Spree::PromotionBuilder.new(
+    {
+      base_code: base_code,
+      number_of_codes: number_of_codes
+    },
+    promotion_attrs,
+  ) }
+
+  describe '#initialize' do
+    subject { builder }
+    it 'has the right base code' do
+      expect(subject.base_code).to eq 'abc'
+    end
+
+    it 'has the right base code' do
+      expect(subject.number_of_codes).to eq 1
+    end
+  end
+
+  describe '#valid?' do
+    subject {  builder.valid? }
+
+    it 'is true' do
+      expect(subject).to be
+    end
+
+    context 'promotion is not valid' do
+      let(:promotion_attrs) { { name: nil } }
+
+      it 'is true' do
+        expect(subject).to_not be
+      end
+
+      it 'has errors on the promotion' do
+        subject
+        expect(builder.errors).to_not be_empty
+      end
+    end
+
+    context 'number of codes is invalid' do
+      let(:number_of_codes) { -1 }
+
+      it 'is false ' do
+        expect(subject).to_not be
+      end
+
+      it 'validates numericality' do
+        subject
+        expect(builder.errors.full_messages).to eq ["Number of codes must be greater than 0"]
+      end
+    end
+  end
+
+  describe '#number_of_codes=' do
+    it 'coerces a string' do
+      builder.number_of_codes = '3'
+      expect(builder.number_of_codes).to eq 3
+    end
+
+    it 'is nil for empty string' do
+      builder.number_of_codes = ''
+      expect(builder.number_of_codes).to be_nil
+    end
+  end
+
+  describe "#perform" do
+    subject { builder.perform }
+
+    context 'when the builder is invalid' do
+      let(:number_of_codes) { 'sups' }
+
+      it 'returns false' do
+        expect(subject).to_not be
+      end
+    end
+
+    context "when the builder is valid" do
+      context "when the builder cant build promotion codes" do
+        let(:number_of_codes) { nil }
+
+        it "doesn't create any new codes" do
+          subject
+          expect(builder.promotion.codes).to be_empty
+        end
+      end
+
+      context "when the builder can build promotion codes" do
+        let(:number_of_codes) { 1 }
+
+        it "creates the correct number of codes" do
+          subject
+          expect(builder.promotion.codes.length).to eq number_of_codes
+        end
+
+        it "creates the promotion with the correct code" do
+          subject
+          expect(builder.promotion.codes.first.value).to eq base_code
+        end
+      end
+
+      it "saves the promotion" do
+        subject
+        expect(builder.promotion).to be_persisted
+      end
+
+      it "returns true on success" do
+        expect(subject).to be true
+      end
+    end
+  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_code/code_builder_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Spree::PromotionCode::CodeBuilder do
+  let(:promotion) { build_stubbed :promotion }
+  let(:base_code) { "abc" }
+  let(:builder) do
+    described_class.new promotion, base_code, num_codes
+  end
+
+  describe "#build_promotion_codes" do
+    subject { builder.build_promotion_codes }
+
+    context "with one code" do
+      let(:num_codes) { 1 }
+
+      it "builds a single promotion code" do
+        subject
+        expect(builder.promotion.codes.size).to eq(num_codes)
+      end
+
+      it "creates the promotion code with the correct value" do
+        subject
+        expect(builder.promotion.codes.first.value).to eq base_code
+      end
+    end
+
+    context "with more than one code" do
+      let(:num_codes) { 2 }
+
+      it "builds the correct number of codes" do
+        subject
+        expect(builder.promotion.codes.size).to eq(num_codes)
+      end
+
+      it "builds codes with distinct values" do
+        subject
+        expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
+      end
+
+      it "builds codes with the same base prefix" do
+        subject
+        values = builder.promotion.codes.map &:value
+        expect(values.all? { |val| val.starts_with?("#{base_code}_") }).to be true
+      end
+
+      context 'when every possible code must be used' do
+        before do
+          @old_length = described_class.random_code_length
+          described_class.random_code_length = 1
+        end
+        after { described_class.random_code_length = @old_length }
+
+        let(:num_codes) { 26 }
+
+        it "resolves the collision" do
+          subject
+          expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
+        end
+      end
+
+      context "when collisions occur" do
+        before do
+          @old_length = described_class.random_code_length
+          described_class.random_code_length = 1
+        end
+        after { described_class.random_code_length = @old_length }
+
+        let(:num_codes) { 25 } # every possible code except 1
+
+        it "resolves the collisions and returns the correct number of codes" do
+          subject
+          expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
+        end
+      end
+
+    end
+  end
+
+end

data/spec/models/spree/promotion_code_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+RSpec.describe Spree::PromotionCode do
+  context 'callbacks' do
+    subject { promotion_code.save }
+
+    describe '#downcase_value' do
+      let(:promotion) { create(:promotion, code: 'NewCoDe') }
+      let(:promotion_code) { promotion.codes.first }
+
+      it 'downcases the value before saving' do
+        subject
+        expect(promotion_code.value).to eq('newcode')
+      end
+    end
+  end
+
+  describe "#usage_limit_exceeded?" do
+    subject { code.usage_limit_exceeded? }
+
+    shared_examples "it should" do
+      context "when there is a usage limit" do
+        context "and the limit is not exceeded" do
+          let(:usage_limit) { 10 }
+          it { is_expected.to be_falsy }
+        end
+        context "and the limit is exceeded" do
+          let(:usage_limit) { 1 }
+          context "on a different order" do
+            before do
+              FactoryGirl.create(
+                :completed_order_with_promotion,
+                promotion: promotion
+              )
+              code.adjustments.update_all(eligible: true)
+            end
+            it { is_expected.to be_truthy }
+          end
+          context "on the same order" do
+            it { is_expected.to be_falsy }
+          end
+        end
+      end
+      context "when there is no usage limit" do
+        let(:usage_limit) { nil }
+        it { is_expected.to be_falsy }
+      end
+    end
+
+    let(:code) { promotion.codes.first }
+
+    context "with an order-level adjustment" do
+      let(:promotion) do
+        FactoryGirl.create(
+          :promotion,
+          :with_order_adjustment,
+          code: "discount",
+          per_code_usage_limit: usage_limit
+        )
+      end
+      let(:promotable) do
+        FactoryGirl.create(
+          :completed_order_with_promotion,
+          promotion: promotion
+        )
+      end
+      it_behaves_like "it should"
+    end
+
+    context "with an item-level adjustment" do
+      let(:promotion) do
+        FactoryGirl.create(
+          :promotion,
+          :with_line_item_adjustment,
+          code: "discount",
+          per_code_usage_limit: usage_limit
+        )
+      end
+      before do
+        promotion.actions.first.perform({
+          order: order,
+          promotion: promotion,
+          promotion_code: code
+        })
+      end
+      context "when there are multiple line items" do
+        let(:order) { FactoryGirl.create(:order_with_line_items, line_items_count: 2) }
+        describe "the first item" do
+          let(:promotable) { order.line_items.first }
+          it_behaves_like "it should"
+        end
+        describe "the second item" do
+          let(:promotable) { order.line_items.last }
+          it_behaves_like "it should"
+        end
+      end
+      context "when there is a single line item" do
+        let(:order) { FactoryGirl.create(:order_with_line_items) }
+        let(:promotable) { order.line_items.first }
+        it_behaves_like "it should"
+      end
+    end
+  end
+
+  describe "#usage_count" do
+    let(:promotion) do
+      FactoryGirl.create(
+        :promotion,
+        :with_order_adjustment,
+        code: "discount"
+      )
+    end
+    let(:code) { promotion.codes.first }
+
+    subject { code.usage_count }
+
+    context "when the code is applied to a non-complete order" do
+      let(:order) { FactoryGirl.create(:order_with_line_items) }
+      before { promotion.activate(order: order, promotion_code: code) }
+      it { is_expected.to eq 0 }
+    end
+    context "when the code is applied to a complete order" do
+      let!(:order) do
+        FactoryGirl.create(
+          :completed_order_with_promotion,
+          promotion: promotion
+        )
+      end
+      context "and the promo is eligible" do
+        it { is_expected.to eq 1 }
+      end
+      context "and the promo is ineligible" do
+        before { order.adjustments.promotion.update_all(eligible: false) }
+        it { is_expected.to eq 0 }
+      end
+    end
+  end
+
+  describe "completing multiple orders with the same code", slow: true do
+    let(:promotion) do
+      FactoryGirl.create(
+        :promotion,
+        :with_order_adjustment,
+        code: "discount",
+        per_code_usage_limit: 1
+      )
+    end
+    let(:code) { promotion.codes.first }
+    let(:order) do
+      FactoryGirl.create(:order_with_line_items).tap do |order|
+        FactoryGirl.create(:payment, amount: order.total, order: order)
+        promotion.activate(order: order, promotion_code: code)
+      end
+    end
+    let(:promo_adjustment) { order.adjustments.promotion.first }
+    before do
+      order.next! until order.confirm?
+
+      FactoryGirl.create(:order_with_line_items).tap do |order|
+        FactoryGirl.create(:payment, amount: order.total, order: order)
+        promotion.activate(order: order, promotion_code: code)
+        order.next! until order.confirm?
+        order.complete!
+      end
+    end
+    it "makes the promotion ineligible" do
+      expect{
+        order.complete
+      }.to change{ promo_adjustment.reload.eligible }.to(false)
+    end
+    it "adjusts the promo_total" do
+      expect{
+        order.complete
+      }.to change(order, :promo_total).by(10)
+    end
+    it "adjusts the total" do
+      expect{
+        order.complete
+      }.to change(order, :total).by(10)
+    end
+    it "resets the state of the order" do
+      expect{
+        order.complete
+      }.to change{ order.reload.state }.from("confirm").to("address")
+    end
+  end
+end