solidus_core 1.0.2 → 1.0.3

data/spec/models/spree/inventory_unit_spec.rb

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

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