solidus_core 1.0.7 → 1.1.0.beta1

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

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

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

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

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

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

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