solidus_core 1.0.2 → 1.0.3

data/spec/models/spree/order_inventory_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+describe Spree::OrderInventory, :type => :model do
+  let(:order) { create :completed_order_with_totals }
+  let(:line_item) { order.line_items.first }
+
+  subject { described_class.new(order, line_item) }
+
+  context "when order is missing inventory units" do
+    before { line_item.update_column(:quantity, 2) }
+
+    it 'creates the proper number of inventory units' do
+      subject.verify
+      expect(subject.inventory_units.count).to eq 2
+    end
+  end
+
+  context "#add_to_shipment" do
+    let(:shipment) { order.shipments.first }
+
+    context "order is not completed" do
+      before { allow(order).to receive_messages completed?: false }
+
+      it "doesn't unstock items" do
+        expect(shipment.stock_location).not_to receive(:unstock)
+        expect(subject.send(:add_to_shipment, shipment, 5)).to eq(5)
+      end
+    end
+
+    context "inventory units state" do
+      before { shipment.inventory_units.destroy_all }
+
+      it 'sets inventory_units state as per stock location availability' do
+        expect(shipment.stock_location).to receive(:fill_status).with(subject.variant, 5).and_return([3, 2])
+
+        expect(subject.send(:add_to_shipment, shipment, 5)).to eq(5)
+
+        units = shipment.inventory_units_for(subject.variant).group_by(&:state)
+        expect(units['backordered'].size).to eq(2)
+        expect(units['on_hand'].size).to eq(3)
+      end
+    end
+
+    context "store doesnt track inventory" do
+      let(:variant) { create(:variant) }
+
+      before { Spree::Config.track_inventory_levels = false }
+
+      it "creates only on hand inventory units" do
+        variant.stock_items.destroy_all
+
+        # The before_save callback in LineItem would verify inventory
+        line_item = order.contents.add variant, 1, shipment: shipment
+
+        units = shipment.inventory_units_for(line_item.variant)
+        expect(units.count).to eq 1
+        expect(units.first).to be_on_hand
+      end
+    end
+
+    context "variant doesnt track inventory" do
+      let(:variant) { create(:variant) }
+      before { variant.track_inventory = false }
+
+      it "creates only on hand inventory units" do
+        variant.stock_items.destroy_all
+
+        line_item = order.contents.add variant, 1
+        subject.verify(shipment)
+
+        units = shipment.inventory_units_for(line_item.variant)
+        expect(units.count).to eq 1
+        expect(units.first).to be_on_hand
+      end
+    end
+
+    it 'should create stock_movement' do
+      expect(subject.send(:add_to_shipment, shipment, 5)).to eq(5)
+
+      stock_item = shipment.stock_location.stock_item(subject.variant)
+      movement = stock_item.stock_movements.last
+      # movement.originator.should == shipment
+      expect(movement.quantity).to eq(-5)
+    end
+  end
+
+  context "#determine_target_shipment" do
+    let(:stock_location) { create :stock_location }
+    let(:variant) { line_item.variant }
+
+    before do
+      subject.verify
+
+      order.shipments.create(:stock_location_id => stock_location.id, :cost => 5)
+
+      shipped = order.shipments.create(:stock_location_id => order.shipments.first.stock_location.id, :cost => 10)
+      shipped.update_column(:state, 'shipped')
+    end
+
+    it 'should select first non-shipped shipment that already contains given variant' do
+      shipment = subject.send(:determine_target_shipment)
+      expect(shipment.shipped?).to be false
+      expect(shipment.inventory_units_for(variant)).not_to be_empty
+
+      expect(variant.stock_location_ids.include?(shipment.stock_location_id)).to be true
+    end
+
+    context "when no shipments already contain this varint" do
+      before do
+        subject.line_item.reload
+        subject.inventory_units.destroy_all
+      end
+
+      it 'selects first non-shipped shipment that leaves from same stock_location' do
+        shipment = subject.send(:determine_target_shipment)
+        shipment.reload
+        expect(shipment.shipped?).to be false
+        expect(shipment.inventory_units_for(variant)).to be_empty
+        expect(variant.stock_location_ids.include?(shipment.stock_location_id)).to be true
+      end
+    end
+  end
+
+  context 'when order has too many inventory units' do
+    before do
+      line_item.quantity = 3
+      line_item.save!
+
+      line_item.update_column(:quantity, 2)
+      subject.line_item.reload
+    end
+
+    it 'should be a messed up order' do
+      expect(order.shipments.first.inventory_units_for(line_item.variant).size).to eq(3)
+      expect(line_item.quantity).to eq(2)
+    end
+
+    it 'should decrease the number of inventory units' do
+      subject.verify
+      expect(subject.inventory_units.count).to eq 2
+    end
+
+    context '#remove_from_shipment' do
+      let(:shipment) { order.shipments.first }
+      let(:variant) { subject.variant }
+
+      context "order is not completed" do
+        before { allow(order).to receive_messages completed?: false }
+
+        it "doesn't restock items" do
+          expect(shipment.stock_location).not_to receive(:restock)
+          expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+        end
+      end
+
+      it 'should create stock_movement' do
+        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+
+        stock_item = shipment.stock_location.stock_item(variant)
+        movement = stock_item.stock_movements.last
+        # movement.originator.should == shipment
+        expect(movement.quantity).to eq(1)
+      end
+
+      it 'should destroy backordered units first' do
+        allow(shipment).to receive_messages(inventory_units_for_item: [
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'backordered'),
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand'),
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'backordered')
+        ])
+
+        expect(shipment.inventory_units_for_item[0]).to receive(:destroy)
+        expect(shipment.inventory_units_for_item[1]).not_to receive(:destroy)
+        expect(shipment.inventory_units_for_item[2]).to receive(:destroy)
+
+        expect(subject.send(:remove_from_shipment, shipment, 2)).to eq(2)
+      end
+
+      it 'should destroy unshipped units first' do
+        allow(shipment).to receive_messages(inventory_units_for_item: [
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'shipped'),
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand')
+        ])
+
+        expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
+        expect(shipment.inventory_units_for_item[1]).to receive(:destroy)
+
+        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+      end
+
+      it 'only attempts to destroy as many units as are eligible, and return amount destroyed' do
+        allow(shipment).to receive_messages(inventory_units_for_item: [
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'shipped'),
+          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand')
+        ])
+
+        expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
+        expect(shipment.inventory_units_for_item[1]).to receive(:destroy)
+
+        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+      end
+
+      it 'should destroy self if not inventory units remain' do
+        allow(shipment.inventory_units).to receive_messages(:count => 0)
+        expect(shipment).to receive(:destroy)
+
+        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+      end
+
+      context "inventory unit line item and variant points to different products" do
+        let(:different_line_item) { create(:line_item) }
+
+        let!(:different_inventory) do
+          shipment.set_up_inventory("on_hand", variant, order, different_line_item)
+        end
+
+        context "completed order" do
+          before { order.touch :completed_at }
+
+          it "removes only units that match both line item and variant" do
+            subject.send(:remove_from_shipment, shipment, shipment.inventory_units.count)
+            expect(different_inventory.reload).to be_persisted
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/order_mutex_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Spree::OrderMutex do
+  let(:order) { create(:order) }
+
+  context "without an existing lock" do
+    it "executes the block" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+
+    it "releases the lock for subsequent calls" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.twice
+    end
+
+    it "returns the value of the block" do
+      expect(Spree::OrderMutex.with_lock!(order) { 'yay for spree' }).to eq 'yay for spree'
+    end
+  end
+
+  context "with an existing lock on the same order" do
+    it "raises a LockFailed error and then releases the lock" do
+      Spree::OrderMutex.with_lock!(order) do
+        expect {
+          expect { |b|
+            Spree::OrderMutex.with_lock!(order, &b)
+          }.not_to yield_control
+        }.to raise_error(Spree::OrderMutex::LockFailed)
+      end
+
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+  end
+
+  context "with an expired existing lock on the same order" do
+    around do |example|
+      Spree::OrderMutex.with_lock!(order) do
+        future = Spree::Config[:order_mutex_max_age].seconds.from_now + 1.second
+        Timecop.freeze(future) do
+          example.run
+        end
+      end
+    end
+
+    it "executes the block" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+  end
+
+  context "with an existing lock on a different order" do
+    let(:order2) { create(:order) }
+
+    around do |example|
+      Spree::OrderMutex.with_lock!(order2) { example.run }
+    end
+
+    it "executes the block" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+  end
+
+  context "when an unrelated RecordNotUnique error occurs" do
+    def raise_record_not_unique
+      raise ActiveRecord::RecordNotUnique.new("Testing")
+    end
+
+    it "does not rescue the unrelated error" do
+      expect {
+        Spree::OrderMutex.with_lock!(order) do
+          raise_record_not_unique
+        end
+      }.to raise_error(ActiveRecord::RecordNotUnique)
+    end
+  end
+end

data/spec/models/spree/order_promotion_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Spree::OrderPromotion do
+  subject do
+    order_promotion
+  end
+
+  let(:order_promotion) { build(:order_promotion) }
+
+  describe "promotion code presence error" do
+    subject do
+      order_promotion.valid?
+      order_promotion.errors[:promotion_code]
+    end
+
+    let(:order_promotion) { build(:order_promotion) }
+    let(:promotion) { order_promotion.promotion }
+
+    context "when the promotion does not have a code" do
+      it { is_expected.to be_blank }
+    end
+
+    context "when the promotion has a code" do
+      let!(:promotion_code) do
+        promotion.codes << build(:promotion_code, promotion: promotion)
+      end
+
+      it { is_expected.to include("can't be blank") }
+    end
+  end
+end

data/spec/models/spree/order_shipping_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+describe Spree::OrderShipping do
+  let(:order) { create(:order_ready_to_ship, line_items_count: 1) }
+
+  def emails
+    ActionMailer::Base.deliveries
+  end
+
+  shared_examples 'shipment shipping' do
+
+    it "marks the inventory units as shipped" do
+      expect { subject }.to change { order.inventory_units.reload.map(&:state) }.from(['on_hand']).to(['shipped'])
+    end
+
+    it "creates a carton with the shipment's inventory units" do
+      expect { subject }.to change { order.cartons.count }.by(1)
+      expect(subject.inventory_units).to match_array(shipment.inventory_units)
+    end
+
+    describe "shipment email" do
+      before { with_test_mail { subject } }
+
+      it "should send a shipment email" do
+        expect(emails.size).to eq(1)
+        expect(emails.first.subject).to eq("#{order.store.name} Shipment Notification ##{order.number}")
+      end
+    end
+
+    it "updates the order shipment state" do
+      expect { subject }.to change { order.reload.shipment_state }.from('ready').to('shipped')
+    end
+
+    it "updates shipment.shipped_at" do
+      Timecop.freeze do |now|
+        expect { subject }.to change { shipment.shipped_at }.from(nil).to(now)
+      end
+    end
+
+    it "updates order.updated_at" do
+      future = 1.minute.from_now
+      expect do
+        Timecop.freeze(future) do
+          subject
+        end
+      end.to change { order.updated_at }.from(order.updated_at).to(future)
+    end
+
+  end
+
+  describe "#ship" do
+    subject do
+      order.shipping.ship(
+        inventory_units: inventory_units,
+        stock_location: stock_location,
+        address: address,
+        shipping_method: shipping_method,
+      )
+    end
+
+    let(:shipment) { order.shipments.to_a.first }
+    let(:inventory_units) { shipment.inventory_units }
+    let(:stock_location) { shipment.stock_location }
+    let(:address) { shipment.address }
+    let(:shipping_method) { shipment.shipping_method }
+
+    it_behaves_like 'shipment shipping'
+
+    context "with an external_number" do
+      subject do
+        order.shipping.ship(
+          inventory_units: inventory_units,
+          stock_location: stock_location,
+          address: address,
+          shipping_method: shipping_method,
+          external_number: 'some-external-number',
+        )
+      end
+
+      it "sets the external_number" do
+        expect(subject.external_number).to eq 'some-external-number'
+      end
+    end
+
+    context "with a tracking number" do
+      subject do
+        order.shipping.ship(
+          inventory_units: inventory_units,
+          stock_location: stock_location,
+          address: address,
+          shipping_method: shipping_method,
+          tracking_number: 'tracking-number',
+        )
+      end
+
+      it "sets the tracking-number" do
+        expect(subject.tracking).to eq 'tracking-number'
+      end
+    end
+
+    context "when told to suppress the mailer" do
+      before { with_test_mail { subject } }
+
+      subject do
+        order.shipping.ship(
+          inventory_units: inventory_units,
+          stock_location: stock_location,
+          address: address,
+          shipping_method: shipping_method,
+          suppress_mailer: true,
+        )
+      end
+
+      it "does not send a shipment email" do
+        expect(emails.size).to eq(0)
+      end
+    end
+  end
+
+  describe "#ship_shipment" do
+    subject { order.shipping.ship_shipment(shipment) }
+
+    let(:shipment) { order.shipments.to_a.first }
+
+    it_behaves_like 'shipment shipping'
+
+    context "when not all units are shippable" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
+      let(:shippable_line_item) { order.line_items.first }
+      let(:unshippable_line_item) { order.line_items.last }
+
+      before do
+        unshippable_line_item.inventory_units.each(&:cancel!)
+      end
+
+      it "only ships the shippable ones" do
+        expect(subject.inventory_units).to match_array(shippable_line_item.inventory_units)
+      end
+    end
+
+    context "when all units are canceled or shipped" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
+
+      before { Spree::OrderCancellations.new(order).short_ship([order.inventory_units.first]) }
+
+      it "updates the order shipment state" do
+        expect { subject }.to change { order.reload.shipment_state }.from('ready').to('shipped')
+      end
+    end
+
+    context "with an external_number" do
+      subject do
+        order.shipping.ship_shipment(
+          shipment,
+          external_number: 'some-external-number',
+        )
+      end
+
+      it "sets the external_number" do
+        expect(subject.external_number).to eq 'some-external-number'
+      end
+    end
+
+    context "with a tracking number" do
+      subject do
+        order.shipping.ship_shipment(
+          shipment,
+          tracking_number: 'tracking-number',
+        )
+      end
+
+      it "sets the tracking-number" do
+        expect(subject.tracking).to eq 'tracking-number'
+      end
+    end
+
+    # TODO: We can remove this once Shipment#ship! is called by
+    # OrderShipping#ship rather than vice versa
+    context "when the tracking number is already on the shipment" do
+      before do
+        shipment.update_attributes!(tracking: 'tracking-number')
+      end
+
+      it "sets the tracking-number" do
+        expect(subject.tracking).to eq 'tracking-number'
+      end
+    end
+
+    context "when the shipment has been partially shipped previously" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
+      let(:inventory_units) { shipment.inventory_units.to_a }
+      let(:shipped_inventory) { [inventory_units.first] }
+      let(:unshipped_inventory) { [inventory_units.last] }
+
+      before do
+        order.shipping.ship(
+          inventory_units: shipped_inventory,
+          stock_location: shipment.stock_location,
+          address: shipment.address,
+          shipping_method: shipment.shipping_method,
+        )
+      end
+
+      it "marks the inventory units as shipped" do
+        expect { subject }.to change { unshipped_inventory.map(&:reload).map(&:state) }.from(['on_hand']).to(['shipped'])
+      end
+
+      it "creates a carton with the shipment's inventory units" do
+        expect { subject }.to change { order.cartons.count }.by(1)
+        expect(subject.inventory_units).to match_array(unshipped_inventory)
+      end
+    end
+
+    context "when told to suppress the mailer" do
+      before { with_test_mail { subject } }
+
+      subject do
+        order.shipping.ship_shipment(
+          shipment,
+          suppress_mailer: true,
+        )
+      end
+
+      it "does not send a shipment email" do
+        expect(emails.size).to eq(0)
+      end
+    end
+
+    context "with stale inventory units (regression test)" do
+      let(:order) { FactoryGirl.create(:order_ready_to_ship, line_items_count: 1) }
+      let(:shipment) do
+        FactoryGirl.create(
+          :shipment,
+          order: order,
+          address: FactoryGirl.create(:address)
+        )
+      end
+
+      before { shipment.ready! }
+
+      it "updates the state to shipped" do
+        order.shipping.ship_shipment(shipment)
+        expect(shipment.reload.state).to eq "shipped"
+      end
+    end
+  end
+end