solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/order_inventory_spec.rb

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

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

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

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