solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/promotion/actions/create_adjustment_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Promotion::Actions::CreateAdjustment, :type => :model do
-  let(:order) { create(:order_with_line_items, :line_items_count => 1) }
-  let(:promotion) { create(:promotion) }
-  let(:action) { Spree::Promotion::Actions::CreateAdjustment.new }
-  let(:payload) { { order: order } }
-
-  # From promotion spec:
-  context "#perform" do
-    before do
-      action.calculator = Spree::Calculator::FlatRate.new(:preferred_amount => 10)
-      promotion.promotion_actions = [action]
-      allow(action).to receive_messages(:promotion => promotion)
-    end
-
-    # Regression test for #3966
-    it "does not apply an adjustment if the amount is 0" do
-      action.calculator.preferred_amount = 0
-      action.perform(payload)
-      expect(promotion.usage_count).to eq(0)
-      expect(order.adjustments.count).to eq(0)
-    end
-
-    it "should create a discount with correct negative amount" do
-      order.shipments.create!(:cost => 10)
-
-      action.perform(payload)
-      expect(promotion.usage_count).to eq(0)
-      expect(order.adjustments.count).to eq(1)
-      expect(order.adjustments.first.amount.to_i).to eq(-10)
-    end
-
-    it "should create a discount accessible through both order_id and adjustable_id" do
-      action.perform(payload)
-      expect(order.adjustments.count).to eq(1)
-      expect(order.all_adjustments.count).to eq(1)
-    end
-
-    it "should not create a discount when order already has one from this promotion" do
-      order.shipments.create!(:cost => 10)
-
-      action.perform(payload)
-      action.perform(payload)
-      expect(promotion.usage_count).to eq(0)
-      expect(order.adjustments.count).to eq(1)
-    end
-
-    context "when a promotion code is used" do
-      let(:promotion_code) { create(:promotion_code) }
-      let(:promotion) { promotion_code.promotion }
-      let(:payload) { { order: order, promotion_code: promotion_code } }
-
-      it "should connect the adjustment to the promotion_code" do
-        expect {
-          action.perform(payload)
-        }.to change { order.adjustments.count }.by(1)
-        expect(order.adjustments.last.promotion_code).to eq promotion_code
-      end
-    end
-  end
-
-  context "#destroy" do
-    before(:each) do
-      action.calculator = Spree::Calculator::FlatRate.new(:preferred_amount => 10)
-      promotion.promotion_actions = [action]
-    end
-
-    context "when order is not complete" do
-      it "should not keep the adjustment" do
-        action.perform(payload)
-        action.destroy
-        expect(order.adjustments.count).to eq(0)
-      end
-    end
-
-    context "when order is complete" do
-      let(:order) do
-        create(:completed_order_with_totals, :line_items_count => 1)
-      end
-
-      before(:each) do
-        action.perform(payload)
-        action.destroy
-      end
-
-      it "should keep the adjustment" do
-        expect(order.adjustments.count).to eq(1)
-      end
-
-      it "should nullify the adjustment source" do
-        expect(order.adjustments.reload.first.source).to be_nil
-      end
-    end
-  end
-end

data/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  class Promotion
-    module Actions
-      describe CreateItemAdjustments, :type => :model do
-        let(:order) { create(:order) }
-        let(:promotion) { create(:promotion) }
-        let(:action) { CreateItemAdjustments.new }
-        let!(:line_item) { create(:line_item, :order => order) }
-        let(:payload) { { order: order, promotion: promotion } }
-
-        before do
-          allow(action).to receive(:promotion).and_return(promotion)
-          promotion.promotion_actions = [action]
-        end
-
-        context "#perform" do
-          # Regression test for #3966
-          context "when calculator computes 0" do
-            before do
-              allow(action).to receive_messages :compute_amount => 0
-            end
-
-            it "does not create an adjustment when calculator returns 0" do
-              action.perform(payload)
-              expect(action.adjustments).to be_empty
-            end
-          end
-
-          context "when calculator returns a non-zero value" do
-            before do
-              promotion.promotion_actions = [action]
-              allow(action).to receive_messages :compute_amount => 10
-            end
-
-            it "creates adjustment with item as adjustable" do
-              action.perform(payload)
-              expect(action.adjustments.count).to eq(1)
-              expect(line_item.reload.adjustments).to eq(action.adjustments)
-            end
-
-            it "creates adjustment with self as source" do
-              action.perform(payload)
-              expect(line_item.reload.adjustments.first.source).to eq action
-            end
-
-            it "does not perform twice on the same item" do
-              2.times { action.perform(payload) }
-              expect(action.adjustments.count).to eq(1)
-            end
-
-            context "with products rules" do
-              let(:rule) { double Spree::Promotion::Rules::Product }
-
-              before { allow(promotion).to receive(:eligible_rules) { [rule] } }
-
-              context "when the rule is actionable" do
-                before { allow(rule).to receive(:actionable?).and_return(true) }
-
-                it "creates an adjustment" do
-                  expect {
-                    expect {
-                      action.perform(payload)
-                    }.to change { action.adjustments.count }.by(1)
-                  }.to change { line_item.adjustments.count }.by(1)
-
-                  expect(action.adjustments.last).to eq line_item.adjustments.last
-                end
-              end
-
-              context "when the rule is not actionable" do
-                before { allow(rule).to receive(:actionable?).and_return(false) }
-
-                it "does not create an adjustment" do
-                  expect {
-                    expect {
-                      action.perform(payload)
-                    }.to_not change { action.adjustments.count }
-                  }.to_not change { line_item.adjustments.count }
-                end
-              end
-            end
-
-            context "when a promotion code is used" do
-              let(:promotion_code) { create(:promotion_code) }
-              let(:promotion) { promotion_code.promotion }
-              let(:payload) { { order: order, promotion: promotion, promotion_code: promotion_code } }
-
-              it "should connect the adjustment to the promotion_code" do
-                expect {
-                  action.perform(payload)
-                }.to change { line_item.adjustments.count }.by(1)
-                expect(line_item.adjustments.last.promotion_code).to eq promotion_code
-              end
-            end
-          end
-        end
-
-        context "#compute_amount" do
-          before { promotion.promotion_actions = [action] }
-
-          context "when the adjustable is actionable" do
-            it "calls compute on the calculator" do
-              expect(action.calculator).to receive(:compute).with(line_item)
-              action.compute_amount(line_item)
-            end
-
-            context "calculator returns amount greater than item total" do
-              before do
-                expect(action.calculator).to receive(:compute).with(line_item).and_return(300)
-                allow(line_item).to receive_messages(amount: 100)
-              end
-
-              it "does not exceed it" do
-                expect(action.compute_amount(line_item)).to eql(-100)
-              end
-            end
-          end
-
-          context "when the adjustable is not actionable" do
-            before { allow(promotion).to receive(:line_item_actionable?) { false } }
-
-            it 'returns 0' do
-              expect(action.compute_amount(line_item)).to eql(0)
-            end
-          end
-        end
-
-        context "#destroy" do
-          let!(:action) { promotion.actions.first }
-          let(:other_action) { other_promotion.actions.first }
-          let(:promotion) { create(:promotion, :with_line_item_adjustment) }
-          let(:other_promotion) { create(:promotion, :with_line_item_adjustment) }
-
-          it "destroys adjustments for incompleted orders" do
-            order = Order.create
-            action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
-
-            expect {
-              action.destroy
-            }.to change { Adjustment.count }.by(-1)
-          end
-
-          it "nullifies adjustments for completed orders" do
-            order = Order.create(completed_at: Time.now)
-            adjustment = action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
-
-            expect {
-              action.destroy
-            }.to change { adjustment.reload.source_id }.from(action.id).to nil
-          end
-
-          it "doesnt mess with unrelated adjustments" do
-            other_action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
-
-            expect {
-              action.destroy
-            }.not_to change { other_action.adjustments.count }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/promotion/actions/create_quantity_adjustments_spec.rb

@@ -1,115 +0,0 @@
-require "spec_helper"
-
-module Spree::Promotion::Actions
-  RSpec.describe CreateQuantityAdjustments do
-    let(:action) { CreateQuantityAdjustments.create!(calculator: calculator, promotion: promotion) }
-
-    let(:order) { FactoryGirl.create :order }
-    let(:promotion) { FactoryGirl.create :promotion }
-
-    describe "#compute_amount" do
-      subject { action.compute_amount(line_item) }
-
-      let!(:item_a) { FactoryGirl.create :line_item, order: order, quantity: quantity, price: 10 }
-
-      context "with a flat rate adjustment" do
-        let(:calculator) { FactoryGirl.create :flat_rate_calculator, preferred_amount: 5 }
-
-        context "with a quantity group of 2" do
-          let(:line_item) { item_a }
-          before { action.preferred_group_size = 2 }
-          context "and an item with a quantity of 0" do
-            let(:quantity) { 0 }
-            it { is_expected.to eq 0 }
-          end
-          context "and an item with a quantity of 1" do
-            let(:quantity) { 1 }
-            it { is_expected.to eq 0 }
-          end
-          context "and an item with a quantity of 2" do
-            let(:quantity) { 2 }
-            it { is_expected.to eq -10 }
-          end
-          context "and an item with a quantity of 3" do
-            let(:quantity) { 3 }
-            it { is_expected.to eq -10 }
-          end
-          context "and an item with a quantity of 4" do
-            let(:quantity) { 4 }
-            it { is_expected.to eq -20 }
-          end
-        end
-
-        context "with a quantity group of 3" do
-          let(:quantity) { 2 }
-          let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1 }
-          let!(:item_c) { FactoryGirl.create :line_item, order: order, quantity: 1 }
-          before { action.preferred_group_size = 3 }
-          context "and 2x item A, 1x item B and 1x item C" do
-            before { action.perform({ order: order, promotion: promotion }) }
-            describe "the adjustment for the first item" do
-              let(:line_item) { item_a }
-              it { is_expected.to eq -10 }
-            end
-            describe "the adjustment for the second item" do
-              let(:line_item) { item_b }
-              it { is_expected.to eq -5 }
-            end
-            describe "the adjustment for the third item" do
-              let(:line_item) { item_c }
-              it { is_expected.to eq 0 }
-            end
-          end
-        end
-
-        context "with multiple orders using the same action" do
-          let(:quantity) { 2 }
-          let(:line_item) { item_a }
-          before do
-            action.preferred_group_size = 2
-            other_order = FactoryGirl.create :order
-            FactoryGirl.create :line_item, order: other_order, quantity: 3
-            action.perform({ order: other_order, promotion: promotion })
-          end
-          it { is_expected.to eq -10 }
-        end
-      end
-
-      context "with a percentage based adjustment" do
-        let(:calculator) { FactoryGirl.create :percent_on_item_calculator, preferred_percent: 10 }
-
-        context "with a quantity group of 3" do
-          before do
-            action.preferred_group_size = 3
-            action.perform({ order: order, promotion: promotion })
-          end
-          context "and 2x item A and 1x item B" do
-            let(:quantity) { 2 }
-            let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1, price: 10 }
-            describe "the adjustment for the first item" do
-              let(:line_item) { item_a }
-              it { is_expected.to eq -2 }
-            end
-            describe "the adjustment for the second item" do
-              let(:line_item) { item_b }
-              it { is_expected.to eq -1 }
-            end
-          end
-
-          context "and the items cost different amounts" do
-            let(:quantity) { 3 }
-            let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1, price: 20 }
-            describe "the adjustment for the first item" do
-              let(:line_item) { item_a }
-              it { is_expected.to eq -3 }
-            end
-            describe "the adjustment for the second item" do
-              let(:line_item) { item_b }
-              it { is_expected.to eq 0 }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/promotion/actions/free_shipping_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Promotion::Actions::FreeShipping, :type => :model do
-  let(:order) { create(:completed_order_with_totals) }
-  let(:promotion_code) { create(:promotion_code, value: 'somecode') }
-  let(:promotion) { promotion_code.promotion }
-  let(:action) { Spree::Promotion::Actions::FreeShipping.create }
-  let(:payload) { { order: order, promotion_code: promotion_code } }
-
-  # From promotion spec:
-  context "#perform" do
-    before do
-      order.shipments << create(:shipment)
-      promotion.promotion_actions << action
-    end
-
-    context "when valid" do
-      it "should create a discount with correct negative amount" do
-        expect(order.shipments.count).to eq(2)
-        expect(order.shipments.first.cost).to eq(100)
-        expect(order.shipments.last.cost).to eq(100)
-        expect(action.perform(payload)).to be true
-        expect(promotion.usage_count).to eq(1)
-        expect(order.shipment_adjustments.count).to eq(2)
-        expect(order.shipment_adjustments.first.amount.to_i).to eq(-100)
-        expect(order.shipment_adjustments.last.amount.to_i).to eq(-100)
-        expect(order.shipment_adjustments.map(&:promotion_code)).to eq [promotion_code, promotion_code]
-      end
-    end
-
-    context "when order already has one from this promotion" do
-      it "should not create a discount" do
-        expect(action.perform(payload)).to be true
-        expect(action.perform(payload)).to be false
-        expect(promotion.usage_count).to eq(1)
-        expect(order.shipment_adjustments.count).to eq(2)
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Promotion::Rules::FirstOrder, :type => :model do
-  let(:rule) { Spree::Promotion::Rules::FirstOrder.new }
-  let(:order) { mock_model(Spree::Order, :user => nil, :email => nil) }
-  let(:user) { mock_model(Spree::LegacyUser) }
-
-  context "without a user or email" do
-    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 or provide your email before applying this coupon code."
-    end
-  end
-
-  context "first order" do
-    context "for a signed user" do
-      context "with no completed orders" do
-        before(:each) do
-          allow(user).to receive_message_chain(:orders, :complete => [])
-        end
-
-        specify do
-          allow(order).to receive_messages(:user => user)
-          expect(rule).to be_eligible(order)
-        end
-
-        it "should be eligible when user passed in payload data" do
-          expect(rule).to be_eligible(order, :user => user)
-        end
-      end
-
-      context "with completed orders" do
-        before(:each) do
-          allow(order).to receive_messages(:user => user)
-        end
-
-        it "should be eligible when checked against first completed order" do
-          allow(user).to receive_message_chain(:orders, :complete => [order])
-          expect(rule).to be_eligible(order)
-        end
-
-        context "with another order" do
-          before { allow(user).to receive_message_chain(:orders, :complete => [mock_model(Spree::Order)]) }
-          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 only be applied to your first order."
-          end
-        end
-      end
-    end
-
-    context "for a guest user" do
-      let(:email) { 'user@spreecommerce.com' }
-      before { allow(order).to receive_messages :email => 'user@spreecommerce.com' }
-
-      context "with no other orders" do
-        it { expect(rule).to be_eligible(order) }
-      end
-
-      context "with another order" do
-        before { allow(rule).to receive_messages(:orders_by_email => [mock_model(Spree::Order)]) }
-        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 only be applied to your first order."
-        end
-      end
-    end
-  end
-end