solidus_core 2.1.1 → 2.2.0.beta1

data/spec/models/spree/order_contents_spec.rb

@@ -19,12 +19,35 @@ describe Spree::OrderContents, type: :model do
     end
 
     context 'given a shipment' do
+      let!(:shipment) { create(:shipment) }
+
       it "ensure shipment calls update_amounts instead of order calling ensure_updated_shipments" do
-        shipment = create(:shipment)
         expect(subject.order).to_not receive(:ensure_updated_shipments)
         expect(shipment).to receive(:update_amounts)
         subject.add(variant, 1, shipment: shipment)
       end
+
+      context "with quantity=1" do
+        it "creates correct inventory" do
+          subject.add(variant, 1, shipment: shipment)
+          expect(order.inventory_units.count).to eq(1)
+        end
+      end
+
+      context "with quantity=2" do
+        it "creates correct inventory" do
+          subject.add(variant, 2, shipment: shipment)
+          expect(order.inventory_units.count).to eq(2)
+        end
+      end
+
+      context "called multiple times" do
+        it "creates correct inventory" do
+          subject.add(variant, 1, shipment: shipment)
+          subject.add(variant, 1, shipment: shipment)
+          expect(order.inventory_units.count).to eq(2)
+        end
+      end
     end
 
     context 'not given a shipment' do

data/spec/models/spree/order_inventory_spec.rb

@@ -3,37 +3,57 @@ require 'spec_helper'
 describe Spree::OrderInventory, type: :model do
   let(:order) { create :completed_order_with_totals }
   let(:line_item) { order.line_items.first }
+  let(:shipment) { order.shipments.first }
+  let(:variant) { subject.variant }
+  let(:stock_item) { shipment.stock_location.stock_item(variant) }
+
 
   subject { described_class.new(order, line_item) }
 
-  context "when order is missing inventory units" do
-    before { line_item.update_column(:quantity, 2) }
+  context "insufficient inventory units" do
+    let(:old_quantity) { 1 }
+    let(:new_quantity) { 3 }
+
+    before do
+      line_item.update_attributes!(quantity: old_quantity)
+
+      line_item.update_column(:quantity, new_quantity)
+      subject.line_item.reload
+    end
 
     it 'creates the proper number of inventory units' do
-      subject.verify
-      expect(subject.inventory_units.count).to eq 2
+      expect(line_item.inventory_units.count).to eq(old_quantity)
+      subject.verify(shipment)
+      expect(line_item.inventory_units.count).to eq(new_quantity)
     end
-  end
 
-  context "#add_to_shipment" do
-    let(:shipment) { order.shipments.first }
+    it "unstocks items" do
+      expect {
+        subject.verify(shipment)
+      }.to change { stock_item.reload.count_on_hand }.by(-2)
+    end
 
     context "order is not completed" do
-      before { allow(order).to receive_messages completed?: false }
+      before { order.update_columns completed_at: nil }
 
       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)
+        expect {
+          subject.verify(shipment)
+        }.not_to change { stock_item.reload.count_on_hand }
       end
     end
 
     context "inventory units state" do
       before { shipment.inventory_units.destroy_all }
+      let(:new_quantity) { 5 }
 
       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])
+        stock_item.update_columns(
+          backorderable: true,
+          count_on_hand: 3
+        )
 
-        expect(subject.send(:add_to_shipment, shipment, 5)).to eq(5)
+        subject.verify
 
         units = shipment.inventory_units_for(subject.variant).group_by(&:state)
         expect(units['backordered'].size).to eq(2)
@@ -42,33 +62,31 @@ describe Spree::OrderInventory, type: :model do
     end
 
     context "store doesnt track inventory" do
-      let(:variant) { create(:variant) }
+      let(:new_quantity) { 1 }
 
       before { Spree::Config.track_inventory_levels = false }
 
-      it "creates only on hand inventory units" do
+      it "creates 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
+        subject.verify(shipment)
 
-        units = shipment.inventory_units_for(line_item.variant)
+        units = shipment.inventory_units_for(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 }
+      before { variant.update_attributes!(track_inventory: false) }
+      let(:new_quantity) { 1 }
 
-      it "creates only on hand inventory units" do
+      it "creates 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)
+        units = shipment.inventory_units_for(variant)
         expect(units.count).to eq 1
         expect(units.first).to be_on_hand
       end
@@ -79,9 +97,21 @@ describe Spree::OrderInventory, type: :model do
 
       stock_item = shipment.stock_location.stock_item(subject.variant)
       movement = stock_item.stock_movements.last
-      # movement.originator.should == shipment
+      expect(movement.originator).to eq(shipment)
       expect(movement.quantity).to eq(-5)
     end
+
+    context "calling multiple times" do
+      it "creates the correct number of inventory units" do
+        line_item.update_columns(quantity: 2)
+        subject.verify(shipment)
+        expect(line_item.inventory_units.count).to eq(2)
+
+        line_item.update_columns(quantity: 3)
+        subject.verify(shipment)
+        expect(line_item.inventory_units.count).to eq(3)
+      end
+    end
   end
 
   context "#determine_target_shipment" do
@@ -122,11 +152,13 @@ describe Spree::OrderInventory, type: :model do
   end
 
   context 'when order has too many inventory units' do
+    let(:old_quantity) { 3 }
+    let(:new_quantity) { 2 }
+
     before do
-      line_item.quantity = 3
-      line_item.save!
+      line_item.update_attributes!(quantity: old_quantity)
 
-      line_item.update_column(:quantity, 2)
+      line_item.update_column(:quantity, new_quantity)
       subject.line_item.reload
     end
 
@@ -137,93 +169,108 @@ describe Spree::OrderInventory, type: :model do
 
     it 'should decrease the number of inventory units' do
       subject.verify
-      expect(subject.inventory_units.count).to eq 2
+      expect(line_item.inventory_units.count).to eq 2
+      expect(order.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 { order.update_columns(completed_at: nil) }
 
-      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)
 
-        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
+        expect {
+          subject.verify(shipment)
+        }.not_to change { stock_item.reload.count_on_hand }
+
+        expect(line_item.inventory_units.count).to eq(new_quantity)
       end
+    end
+
+    it 'should change count_on_hand' do
+      expect {
+        subject.verify(shipment)
+      }.to change { stock_item.reload.count_on_hand }.by(1)
+    end
 
-      it 'should create stock_movement' do
-        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+    it 'should create stock_movement' do
+      stock_item = shipment.stock_location.stock_item(variant)
 
-        stock_item = shipment.stock_location.stock_item(variant)
-        movement = stock_item.stock_movements.last
-        # movement.originator.should == shipment
-        expect(movement.quantity).to eq(1)
+      expect {
+        subject.verify(shipment)
+      }.to change { stock_item.stock_movements.count }.by(1)
+
+      movement = stock_item.stock_movements.last
+      expect(movement.originator).to eq shipment
+      expect(movement.quantity).to eq(1)
+    end
+
+    context 'with some backordered' do
+      let(:new_quantity) { 1 }
+
+      before do
+        line_item.inventory_units[0].update_columns(state: 'backordered')
+        line_item.inventory_units[1].update_columns(state: 'on_hand')
+        line_item.inventory_units[2].update_columns(state: 'backordered')
       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')
-        ])
+        on_hand_unit = line_item.inventory_units.find_by state: 'on_hand'
 
-        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)
+        subject.verify(shipment)
 
-        expect(subject.send(:remove_from_shipment, shipment, 2)).to eq(2)
+        expect(line_item.inventory_units.reload).to eq([on_hand_unit])
       end
+    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')
-        ])
+    context 'with some shipped items' do
+      let(:old_quantity) { 2 }
+      let(:new_quantity) { 1 }
 
-        expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
-        expect(shipment.inventory_units_for_item[1]).to receive(:destroy)
+      let(:shipped_unit) { line_item.inventory_units[0] }
+      before do
+        shipped_unit.update_columns(state: 'shipped')
+      end
+
+      it 'should destroy unshipped units first' do
+        subject.verify(shipment)
 
-        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+        expect(line_item.inventory_units.reload).to eq([shipped_unit])
       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')
-        ])
+      context 'trying to remove shipped units' do
+        let(:new_quantity) { 0 }
 
-        expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
-        expect(shipment.inventory_units_for_item[1]).to receive(:destroy)
+        it 'only attempts to destroy as many units as are eligible, and return amount destroyed' do
+          subject.verify(shipment)
 
-        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+          expect(line_item.inventory_units.reload).to eq([shipped_unit])
+        end
       end
+    end
 
-      it 'should destroy self if not inventory units remain' do
-        shipment.inventory_units[1...999].each(&:destroy)
-        shipment.inventory_units.reload
+    context 'destroying all units' do
+      let(:new_quantity) { 0 }
 
+      it 'should destroy shipment' do
         expect {
-          expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
+          subject.verify(shipment)
         }.to change{ order.shipments.count }.from(1).to(0)
       end
+    end
 
-      context "inventory unit line item and variant points to different products" do
-        let(:different_line_item) { create(:line_item) }
+    context "inventory unit line item and variant points to different products" do
+      let(:new_quantity) { 0 }
+      let(:different_line_item) { create(:line_item, order: order) }
 
-        let!(:different_inventory) do
-          shipment.set_up_inventory("on_hand", variant, order, different_line_item)
-        end
+      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.verify(shipment)
 
-          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
+        expect(different_inventory.reload).to be_persisted
       end
     end
   end

data/spec/models/spree/order_spec.rb

@@ -107,10 +107,11 @@ describe Spree::Order, type: :model do
 
     it "update and persist totals" do
       expect(shipment).to receive :update_amounts
-      expect(order.updater).to receive :update_shipment_total
-      expect(order.updater).to receive :persist_totals
+      expect(order.updater).to receive :update
 
-      order.set_shipments_cost
+      Spree::Deprecation.silence do
+        order.set_shipments_cost
+      end
     end
   end
 
@@ -537,6 +538,16 @@ describe Spree::Order, type: :model do
       expect(order.available_payment_methods).to include(payment_method)
     end
 
+    it "does not include inactive payment methods" do
+      Spree::PaymentMethod.create!({
+        name: "Fake",
+        active: false,
+        available_to_users: true,
+        available_to_admin: true
+      })
+      expect(order.available_payment_methods.count).to eq(0)
+    end
+
     context "with more than one payment method" do
       subject { order.available_payment_methods }
 
@@ -550,7 +561,7 @@ describe Spree::Order, type: :model do
       end
 
       it "respects the order of methods based on position" do
-        expect(subject).to eql([second_method, first_method])
+        expect(subject).to eq([second_method, first_method])
       end
     end
 
@@ -956,25 +967,6 @@ describe Spree::Order, type: :model do
 
       expect { shipment.reload }.not_to raise_error
     end
-
-    context "unreturned exchange" do
-      let!(:first_shipment) do
-        create(:shipment, order: subject, state: first_shipment_state, created_at: 5.days.ago)
-      end
-      let!(:second_shipment) do
-        create(:shipment, order: subject, state: second_shipment_state, created_at: 5.days.ago)
-      end
-
-      context "all shipments are shipped" do
-        let(:first_shipment_state) { "shipped" }
-        let(:second_shipment_state) { "shipped" }
-
-        it "returns the shipments" do
-          subject.create_proposed_shipments
-          expect(subject.shipments).to match_array [first_shipment, second_shipment]
-        end
-      end
-    end
   end
 
   describe "#all_inventory_units_returned?" do
@@ -1007,48 +999,6 @@ describe Spree::Order, type: :model do
     end
   end
 
-  describe "#unreturned_exchange?" do
-    let(:order) { create(:order_with_line_items) }
-    subject { order.reload.unreturned_exchange? }
-
-    context "the order does not have a shipment" do
-      before { order.shipments.destroy_all }
-
-      it { is_expected.to be false }
-    end
-
-    context "shipment created after order" do
-      it { is_expected.to be false }
-    end
-
-    context "shipment created before order" do
-      before do
-        order.shipments.first.update_attributes!(created_at: order.created_at - 1.day)
-      end
-
-      it { is_expected.to be true }
-    end
-  end
-
-  describe '.unreturned_exchange' do
-    let(:order) { create(:order_with_line_items) }
-    subject { described_class.unreturned_exchange }
-
-    it 'includes orders that have a shipment created prior to the order' do
-      order.shipments.first.update_attributes!(created_at: order.created_at - 1.day)
-      expect(subject).to include order
-    end
-
-    it 'excludes orders that were created prior to their shipment' do
-      expect(subject).not_to include order
-    end
-
-    it 'excludes orders with no shipment' do
-      order.shipments.destroy_all
-      expect(subject).not_to include order
-    end
-  end
-
   context "store credit" do
     shared_examples "check total store credit from payments" do
       context "with valid payments" do
@@ -1459,56 +1409,4 @@ describe Spree::Order, type: :model do
       end
     end
   end
-
-  describe "#validate_payments_attributes" do
-    let(:attributes) { [ActionController::Parameters.new(payment_method_id: payment_method.id)] }
-    subject do
-      order.validate_payments_attributes(attributes)
-    end
-
-    context "with empty array" do
-      let(:attributes) { [] }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with no payment method specified" do
-      let(:attributes) { [ActionController::Parameters.new({})] }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with valid payment method" do
-      let(:payment_method) { create(:check_payment_method) }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with inactive payment method" do
-      let(:payment_method) { create(:check_payment_method, active: false) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with unavailable payment method" do
-      let(:payment_method) { create(:check_payment_method, available_to_users: false) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with soft-deleted payment method" do
-      let(:payment_method) { create(:check_payment_method, deleted_at: Time.current) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
 end

data/spec/models/spree/order_update_attributes_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Spree
   RSpec.describe OrderUpdateAttributes do
     let(:order) { create(:order) }
-    let(:payment_method) { create(:payment_method) }
     let(:request_env) { nil }
     let(:update) { described_class.new(order, attributes, request_env: request_env) }
 
@@ -26,10 +25,7 @@ module Spree
       let(:attributes) do
         {
           payments_attributes: [
-            {
-              payment_method_id: payment_method.id,
-              source_attributes: attributes_for(:credit_card)
-            }
+            { source_attributes: attributes_for(:credit_card) }
           ]
         }
       end
@@ -43,44 +39,5 @@ module Spree
         end
       end
     end
-
-    context 'when changing shipping method' do
-      let!(:order) { create(:order_with_line_items, shipping_method: shipping_method1) }
-      let(:shipment){ order.shipments.first }
-      let!(:zone) { create(:zone) }
-      let!(:shipping_method1){ create(:shipping_method, cost: 10, zones: [zone]) }
-      let!(:shipping_method2){ create(:shipping_method, cost: 20, zones: [zone]) }
-
-      let(:attributes) do
-        {
-          shipments_attributes: {
-            0 => { selected_shipping_rate_id: shipping_method2, id: shipment.id }
-          }
-        }
-      end
-
-      it "updates shipment costs" do
-        zone.zone_members.create!(zoneable: order.ship_address.country)
-        order.create_proposed_shipments
-        order.set_shipments_cost
-
-        shipping_rate2 = shipment.shipping_rates.find_by(shipping_method_id: shipping_method2.id)
-
-        expect(order.shipment_total).to eq(10)
-
-        # We need an order which doesn't have shipping_rates loaded
-        order.reload
-
-        described_class.new(
-          order,
-          shipments_attributes: {
-            0 => { selected_shipping_rate_id: shipping_rate2.id, id: shipment.id }
-          }
-        ).apply
-
-        expect(order.shipment_total).to eq(20)
-        expect(order.shipments.first.cost).to eq(20)
-      end
-    end
   end
 end

data/spec/models/spree/order_updater_spec.rb

@@ -16,20 +16,22 @@ module Spree
       context 'with refund' do
         it "updates payment totals" do
           create(:payment_with_refund, order: order, amount: 33.25, refund_amount: 3)
-          Spree::OrderUpdater.new(order).update_payment_total
+          updater.update
           expect(order.payment_total).to eq(30.25)
         end
       end
 
       it "update item total" do
-        updater.update_item_total
-        expect(order.item_total).to eq(20)
+        expect {
+          updater.update
+        }.to change { order.item_total }.to 20
       end
 
       it "update shipment total" do
         create(:shipment, order: order, cost: 10)
-        updater.update_shipment_total
-        expect(order.shipment_total).to eq(10)
+        expect {
+          updater.update
+        }.to change { order.shipment_total }.to 10
       end
 
       context 'with order promotion followed by line item addition' do
@@ -60,7 +62,7 @@ module Spree
         create(:adjustment, adjustable: order, order: order, source: nil, amount: 10)
 
         expect {
-          updater.update_adjustment_total
+          updater.update
         }.to change {
           order.adjustment_total
         }.from(0).to(10)
@@ -483,17 +485,12 @@ module Spree
 
         it "updates each shipment" do
           expect(shipment).to receive(:update!)
-          updater.update_shipments
-        end
-
-        it "refreshes shipment rates" do
-          expect(shipment).to receive(:refresh_rates)
-          updater.update_shipments
+          updater.update
         end
 
         it "updates the shipment amount" do
           expect(shipment).to receive(:update_amounts)
-          updater.update_shipments
+          updater.update
         end
       end
     end

data/spec/models/spree/payment_create_spec.rb

@@ -68,7 +68,7 @@ module Spree
       end
     end
 
-    context 'with an existing credit card' do
+    context 'with the deprecated existing_card_id attribute' do
       let(:user) { create(:user) }
       let!(:credit_card) { create(:credit_card, user: order.user) }
 
@@ -81,6 +81,10 @@ module Spree
         }
       end
 
+      around do |example|
+        Spree::Deprecation.silence { example.run }
+      end
+
       it 'sets the existing card as the source for the new payment' do
         expect(new_payment.source).to eq(credit_card)
       end