solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/inventory_unit_spec.rb

@@ -1,307 +0,0 @@
-require 'spec_helper'
-
-describe Spree::InventoryUnit, :type => :model do
-  let(:stock_location) { create(:stock_location_with_items) }
-  let(:stock_item) { stock_location.stock_items.order(:id).first }
-  let(:line_item) { create(:line_item, variant: stock_item.variant) }
-
-  context "#backordered_for_stock_item" do
-    let(:order) do
-      order = create(:order, state: 'complete', ship_address: create(:ship_address))
-      order.completed_at = Time.now
-      create(:shipment, order: order, stock_location: stock_location)
-      order.shipments.reload
-      create(:line_item, order: order, variant: stock_item.variant)
-      order.line_items.reload
-      order.tap(&:save!)
-    end
-
-    let(:shipment) do
-      order.shipments.first
-    end
-
-    let(:shipping_method) do
-      shipment.shipping_methods.first
-    end
-
-    let!(:unit) do
-      unit = shipment.inventory_units.first
-      unit.state = 'backordered'
-      unit.variant_id = stock_item.variant.id
-      unit.order_id = order.id
-      unit.line_item = line_item
-      unit.tap(&:save!)
-    end
-
-    before do
-      stock_item.set_count_on_hand(-2)
-    end
-
-    # Regression for #3066
-    it "returns modifiable objects" do
-      units = Spree::InventoryUnit.backordered_for_stock_item(stock_item)
-      expect { units.first.save! }.to_not raise_error
-    end
-
-    it "finds inventory units from its stock location when the unit's variant matches the stock item's variant" do
-      expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).to match_array([unit])
-    end
-
-    it "does not find inventory units that aren't backordered" do
-      on_hand_unit = shipment.inventory_units.build
-      on_hand_unit.state = 'on_hand'
-      on_hand_unit.order_id = order.id
-      on_hand_unit.line_item = line_item
-      on_hand_unit.variant = stock_item.variant
-      on_hand_unit.save!
-
-      expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).not_to include(on_hand_unit)
-    end
-
-    it "does not find inventory units that don't match the stock item's variant" do
-      other_variant_unit = shipment.inventory_units.build
-      other_variant_unit.state = 'backordered'
-      other_variant_unit.order_id = order.id
-      other_variant_unit.line_item = line_item
-      other_variant_unit.variant = create(:variant)
-      other_variant_unit.save!
-
-      expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).not_to include(other_variant_unit)
-    end
-
-    it "does not change shipping cost when fulfilling the order" do
-      current_shipment_cost = shipment.cost
-      shipping_method.calculator.set_preference(:amount, current_shipment_cost + 5.0)
-      stock_item.set_count_on_hand(0)
-      expect(shipment.reload.cost).to eq(current_shipment_cost)
-    end
-
-    context "other shipments" do
-      let(:other_order) do
-        order = create(:order)
-        order.state = 'payment'
-        order.completed_at = nil
-        order.tap(&:save!)
-      end
-
-      let(:other_shipment) do
-        shipment = Spree::Shipment.new
-        shipment.stock_location = stock_location
-        shipment.shipping_methods << create(:shipping_method)
-        shipment.order = other_order
-        # We don't care about this in this test
-        allow(shipment).to receive(:ensure_correct_adjustment)
-        shipment.tap(&:save!)
-      end
-
-      let!(:other_unit) do
-        unit = other_shipment.inventory_units.build
-        unit.state = 'backordered'
-        unit.variant_id = stock_item.variant.id
-        unit.order_id = other_order.id
-        unit.line_item = line_item
-        unit.tap(&:save!)
-      end
-
-      it "does not find inventory units belonging to incomplete orders" do
-        expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).not_to include(other_unit)
-      end
-
-    end
-
-  end
-
-  context "variants deleted" do
-    let!(:unit) { create(:inventory_unit) }
-
-    it "can still fetch variant" do
-      unit.variant.destroy
-      expect(unit.reload.variant).to be_a Spree::Variant
-    end
-
-    it "can still fetch variants by eager loading (remove default_scope)" do
-      skip "find a way to remove default scope when eager loading associations"
-      unit.variant.destroy
-      expect(Spree::InventoryUnit.joins(:variant).includes(:variant).first.variant).to be_a Spree::Variant
-    end
-  end
-
-  context "#finalize_units!" do
-    let!(:stock_location) { create(:stock_location) }
-    let(:variant) { create(:variant) }
-    let(:inventory_units) { [
-      create(:inventory_unit, variant: variant),
-      create(:inventory_unit, variant: variant)
-    ] }
-
-    it "should create a stock movement" do
-      Spree::InventoryUnit.finalize_units!(inventory_units)
-      expect(inventory_units.any?(&:pending)).to be false
-    end
-  end
-
-  describe "#current_or_new_return_item" do
-    before { allow(inventory_unit).to receive_messages(pre_tax_amount: 100.0) }
-
-    subject { inventory_unit.current_or_new_return_item }
-
-    context "associated with a return item" do
-      let(:return_item) { create(:return_item) }
-      let(:inventory_unit) { return_item.inventory_unit }
-
-      it "returns a persisted return item" do
-        expect(subject).to be_persisted
-      end
-
-      it "returns it's associated return_item" do
-        expect(subject).to eq return_item
-      end
-    end
-
-    context "no associated return item" do
-      let(:inventory_unit) { create(:inventory_unit) }
-
-      it "returns a new return item" do
-        expect(subject).to_not be_persisted
-      end
-
-      it "associates itself to the new return_item" do
-        expect(subject.inventory_unit).to eq inventory_unit
-      end
-    end
-  end
-
-  describe '#additional_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_additional_tax_total)  { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        additional_tax_total: line_item_additional_tax_total,
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.additional_tax_total).to eq line_item_additional_tax_total / quantity
-    end
-  end
-
-  describe '#included_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_included_tax_total)  { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        included_tax_total: line_item_included_tax_total,
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.included_tax_total).to eq line_item_included_tax_total / quantity
-    end
-  end
-
-  describe '#additional_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_additional_tax_total)  { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        additional_tax_total: line_item_additional_tax_total,
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.additional_tax_total).to eq line_item_additional_tax_total / quantity
-    end
-  end
-
-  describe '#included_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_included_tax_total)  { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        included_tax_total: line_item_included_tax_total,
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.included_tax_total).to eq line_item_included_tax_total / quantity
-    end
-  end
-
-  describe "#exchange_requested?" do
-
-    subject { inventory_unit.exchange_requested? }
-
-    context "return item contains inventory unit and was for an exchange" do
-      let(:exchange_return_item) { create(:exchange_return_item) }
-      let(:inventory_unit) { exchange_return_item.inventory_unit }
-      it { is_expected.to eq true }
-    end
-
-    context "return item does not contain inventory unit" do
-      let(:inventory_unit) { create(:inventory_unit) }
-      it { is_expected.to eq false }
-    end
-  end
-
-  context "destroy prevention" do
-    it "can be destroyed when on hand" do
-      inventory_unit = create(:inventory_unit, state: "on_hand")
-      expect(inventory_unit.destroy).to be_truthy
-      expect { inventory_unit.reload }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "can be destroyed when backordered" do
-      inventory_unit = create(:inventory_unit, state: "backordered")
-      expect(inventory_unit.destroy).to be_truthy
-      expect { inventory_unit.reload }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "cannot be destroyed when shipped" do
-      inventory_unit = create(:inventory_unit, state: "shipped")
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-
-    it "cannot be destroyed when returned" do
-      inventory_unit = create(:inventory_unit, state: "returned")
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-
-    it "cannot be destroyed if its shipment is ready" do
-      inventory_unit = create(:order_ready_to_ship).inventory_units.first
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-
-    it "cannot be destroyed if its shipment is shipped" do
-      inventory_unit = create(:shipped_order).inventory_units.first
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-  end
-end

data/spec/models/spree/item_adjustments_spec.rb

@@ -1,256 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe ItemAdjustments, :type => :model do
-    let(:order) { create :order_with_line_items, line_items_count: 1 }
-    let(:line_item) { order.line_items.first }
-
-    let(:subject) { ItemAdjustments.new(line_item) }
-
-    context '#update' do
-      it "updates a linked adjustment" do
-        tax_rate = create(:tax_rate, :amount => 0.05)
-        adjustment = create(:adjustment, order: order, source: tax_rate, adjustable: line_item)
-        line_item.price = 10
-        line_item.tax_category = tax_rate.tax_category
-
-        subject.update
-        expect(line_item.adjustment_total).to eq(0.5)
-        expect(line_item.additional_tax_total).to eq(0.5)
-      end
-    end
-
-    context "taxes and promotions" do
-      let!(:tax_rate) do
-        create(:tax_rate, :amount => 0.05)
-      end
-
-      let!(:promotion) do
-        Spree::Promotion.create(:name => "$10 off")
-      end
-
-      let!(:promotion_action) do
-        calculator = Calculator::FlatRate.new(:preferred_amount => 10)
-        Promotion::Actions::CreateItemAdjustments.create calculator: calculator, promotion: promotion
-      end
-
-      before do
-        line_item.price = 20
-        line_item.tax_category = tax_rate.tax_category
-        line_item.save
-        create(:adjustment, order: order, source: promotion_action, adjustable: line_item)
-      end
-
-      context "tax included in price" do
-        before do
-          create(:adjustment,
-            :source => tax_rate,
-            :adjustable => line_item,
-            :order => order,
-            :included => true
-          )
-        end
-
-        it "tax has no bearing on final price" do
-          subject.update
-          line_item.reload
-          expect(line_item.included_tax_total).to eq(0.5)
-          expect(line_item.additional_tax_total).to eq(0)
-          expect(line_item.promo_total).to eq(-10)
-          expect(line_item.adjustment_total).to eq(-10)
-        end
-
-        it "tax linked to order" do
-          order.update!
-          order.reload
-          expect(order.included_tax_total).to eq(0.5)
-          expect(order.additional_tax_total).to eq(00)
-        end
-      end
-
-      context "tax excluded from price" do
-        before do
-          create(:adjustment,
-            :source => tax_rate,
-            :adjustable => line_item,
-            :order => order,
-            :included => false
-          )
-        end
-
-        it "tax applies to line item" do
-          subject.update
-          line_item.reload
-          # Taxable amount is: $20 (base) - $10 (promotion) = $10
-          # Tax rate is 5% (of $10).
-          expect(line_item.included_tax_total).to eq(0)
-          expect(line_item.additional_tax_total).to eq(0.5)
-          expect(line_item.promo_total).to eq(-10)
-          expect(line_item.adjustment_total).to eq(-9.5)
-        end
-
-        it "tax linked to order" do
-          order.update!
-          expect(order.included_tax_total).to eq(0)
-          expect(order.additional_tax_total).to eq(0.5)
-        end
-      end
-    end
-
-    context "best promotion is always applied" do
-      let(:calculator) { Calculator::FlatRate.new(:preferred_amount => 10) }
-
-      let(:source) do
-        Promotion::Actions::CreateItemAdjustments.create!(
-          calculator: calculator,
-          promotion: promotion,
-        )
-      end
-      let(:promotion) { create(:promotion) }
-
-      def create_adjustment(label, amount)
-        create(:adjustment, :order      => order,
-                            :adjustable => line_item,
-                            :source     => source,
-                            :amount     => amount,
-                            :state      => "closed",
-                            :label      => label,
-                            :mandatory  => false)
-      end
-
-      it "should make all but the most valuable promotion adjustment ineligible, leaving non promotion adjustments alone" do
-        create_adjustment("Promotion A", -100)
-        create_adjustment("Promotion B", -200)
-        create_adjustment("Promotion C", -300)
-        create(:adjustment, :order => order,
-                            :adjustable => line_item,
-                            :source => nil,
-                            :amount => -500,
-                            :state => "closed",
-                            :label => "Some other credit")
-        line_item.adjustments.each {|a| a.update_column(:eligible, true)}
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion C')
-      end
-
-      it "should choose the most recent promotion adjustment when amounts are equal" do
-        # Using Timecop is a regression test
-        Timecop.freeze do
-          create_adjustment("Promotion A", -200)
-          create_adjustment("Promotion B", -200)
-        end
-        line_item.adjustments.each {|a| a.update_column(:eligible, true)}
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
-      end
-
-      it "should choose the most recent promotion adjustment when amounts are equal" do
-        # Using Timecop is a regression test
-        Timecop.freeze do
-          create_adjustment("Promotion A", -200)
-          create_adjustment("Promotion B", -200)
-        end
-        line_item.adjustments.each {|a| a.update_column(:eligible, true)}
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
-      end
-
-      context "when previously ineligible promotions become available" do
-        let(:order_promo1) { create(:promotion, :with_order_adjustment, :with_item_total_rule, weighted_order_adjustment_amount: 5, item_total_threshold_amount: 10) }
-        let(:order_promo2) { create(:promotion, :with_order_adjustment, :with_item_total_rule, weighted_order_adjustment_amount: 10, item_total_threshold_amount: 20) }
-        let(:order_promos) { [ order_promo1, order_promo2 ] }
-        let(:line_item_promo1) { create(:promotion, :with_line_item_adjustment, :with_item_total_rule, adjustment_rate: 2.5, item_total_threshold_amount: 10) }
-        let(:line_item_promo2) { create(:promotion, :with_line_item_adjustment, :with_item_total_rule, adjustment_rate: 5, item_total_threshold_amount: 20) }
-        let(:line_item_promos) { [ line_item_promo1, line_item_promo2 ] }
-        let(:order) { create(:order_with_line_items, line_items_count: 1) }
-
-        # Apply promotions in different sequences. Results should be the same.
-        promo_sequences = [
-          [ 0, 1 ],
-          [ 1, 0 ]
-        ]
-
-        promo_sequences.each do |promo_sequence|
-          it "should pick the best order-level promo according to current eligibility" do
-            # apply both promos to the order, even though only promo1 is eligible
-            order_promos[promo_sequence[0]].activate order: order
-            order_promos[promo_sequence[1]].activate order: order
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(2), "Expected two adjustments (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(1), "Expected one elegible adjustment (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo1), "Expected promo1 to be used (using sequence #{promo_sequence})"
-
-            order.contents.add create(:variant, price: 10), 1
-            order.save
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(2), "Expected two adjustments (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(1), "Expected one elegible adjustment (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo2), "Expected promo2 to be used (using sequence #{promo_sequence})"
-          end
-        end
-
-        promo_sequences.each do |promo_sequence|
-          it "should pick the best line-item-level promo according to current eligibility" do
-            # apply both promos to the order, even though only promo1 is eligible
-            line_item_promos[promo_sequence[0]].activate order: order
-            line_item_promos[promo_sequence[1]].activate order: order
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(1), "Expected one adjustment (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(1), "Expected one elegible adjustment (using sequence #{promo_sequence})"
-            # line_item_promo1 is the only one that has thus far met the order total threshold, it is the only promo which should be applied.
-            expect(order.all_adjustments.first.source.promotion).to eq(line_item_promo1), "Expected line_item_promo1 to be used (using sequence #{promo_sequence})"
-
-            order.contents.add create(:variant, price: 10), 1
-            order.save
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(4), "Expected four adjustments (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(2), "Expected two elegible adjustments (using sequence #{promo_sequence})"
-            order.all_adjustments.eligible.each do |adjustment|
-              expect(adjustment.source.promotion).to eq(line_item_promo2), "Expected line_item_promo2 to be used (using sequence #{promo_sequence})"
-            end
-          end
-        end
-      end
-
-      context "multiple adjustments and the best one is not eligible" do
-        let!(:promo_a) { create_adjustment("Promotion A", -100) }
-        let!(:promo_c) { create_adjustment("Promotion C", -300) }
-
-        before do
-          promo_a.update_column(:eligible, true)
-          promo_c.update_column(:eligible, false)
-        end
-
-        # regression for #3274
-        it "still makes the previous best eligible adjustment valid" do
-          subject.update
-          expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion A')
-        end
-      end
-
-      it "should only leave one adjustment even if 2 have the same amount" do
-        create_adjustment("Promotion A", -100)
-        create_adjustment("Promotion B", -200)
-        create_adjustment("Promotion C", -200)
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.amount.to_i).to eq(-200)
-      end
-    end
-  end
-end