solidus_core 2.7.4 → 2.8.0

data/spec/models/spree/reimbursement_type/credit_spec.rb

@@ -10,13 +10,14 @@ module Spree
     let(:simulate)                { false }
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
     let(:creditable)              { DummyCreditable.new(amount: 99.99) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
     class DummyCreditable < Spree::Base
       attr_accessor :amount
       self.table_name = 'spree_payments' # Your creditable class should not use this table
     end
 
-    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate) }
+    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate, created_by: created_by_user) }
 
     before do
       reimbursement.update!(total: reimbursement.calculated_total)

data/spec/models/spree/reimbursement_type/exchange_spec.rb

@@ -9,8 +9,9 @@ module Spree
       let(:return_items)  { reimbursement.return_items }
       let(:new_exchange)  { double("Exchange") }
       let(:simulate)      { true }
+      let(:created_by_user) { create(:user, email: 'user@email.com') }
 
-      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate) }
+      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate, created_by: created_by_user) }
 
       context 'return items are supplied' do
         before do

data/spec/models/spree/reimbursement_type/original_payment_spec.rb

@@ -9,8 +9,9 @@ module Spree
     let(:payment)                 { reimbursement.order.payments.first }
     let(:simulate)                { false }
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
-    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate) }
+    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate, created_by: created_by_user) }
 
     before { reimbursement.update!(total: reimbursement.calculated_total) }
 

data/spec/models/spree/reimbursement_type/store_credit_spec.rb

@@ -12,10 +12,10 @@ module Spree
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
 
     let!(:primary_credit_type)    { create(:primary_credit_type) }
-    let!(:created_by_user)        { create(:user, email: Spree::StoreCredit::DEFAULT_CREATED_BY_EMAIL) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
     let!(:default_reimbursement_category) { create(:store_credit_category) }
 
-    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate) }
+    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate, created_by: created_by_user) }
 
     before do
       reimbursement.update!(total: reimbursement.calculated_total)
@@ -92,6 +92,18 @@ module Spree
             expect { subject }.to change { Spree::StoreCredit.count }.by(1)
             expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
           end
+
+          context 'without a user with email address "spree@example.com" in the database' do
+            before do
+              default_user = Spree::LegacyUser.find_by(email: "spree@example.com")
+              default_user.destroy if default_user
+            end
+
+            it "creates a store credit with the same currency as the reimbursement's order" do
+              expect { subject }.to change { Spree::StoreCredit.count }.by(1)
+              expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
+            end
+          end
         end
       end
     end

data/spec/models/spree/return_item_spec.rb

@@ -294,7 +294,7 @@ RSpec.describe Spree::ReturnItem, type: :model do
         end
 
         it 'does not decrease inventory' do
-          expect(return_item).to_not receive(:process_inventory_unit)
+          expect(return_item).to_not receive(:process_inventory_unit!)
           subject
         end
 

data/spec/models/spree/shipment_spec.rb

@@ -267,8 +267,8 @@ RSpec.describe Spree::Shipment, type: :model do
 
         before do
           allow(line_item).to receive(:order) { order }
-          allow(shipment).to receive(:inventory_units) { inventory_units }
-          allow(inventory_units).to receive_message_chain(:includes, :joins).and_return inventory_units
+          shipment.inventory_units = inventory_units
+          allow(shipment.inventory_units).to receive_message_chain(:includes, :joins).and_return inventory_units
         end
 
         it 'should use symbols for states when adding contents to package' do
@@ -413,7 +413,9 @@ RSpec.describe Spree::Shipment, type: :model do
       allow(shipment.order).to receive(:update!)
 
       shipment.state = 'pending'
-      expect(shipment).to receive(:after_cancel)
+      without_partial_double_verification do
+        expect(shipment).to receive(:after_cancel)
+      end
       shipment.cancel!
       expect(shipment.state).to eq 'canceled'
     end
@@ -512,7 +514,6 @@ RSpec.describe Spree::Shipment, type: :model do
       let(:subject) { shipment_with_inventory_units.ship! }
       before do
         allow(order).to receive(:update!)
-        allow(shipment_with_inventory_units).to receive_messages(require_inventory: false, update_order: true)
       end
 
       it 'unstocks them items' do
@@ -525,7 +526,7 @@ RSpec.describe Spree::Shipment, type: :model do
       context "from #{state}" do
         before do
           allow(order).to receive(:update!)
-          allow(shipment).to receive_messages(require_inventory: false, update_order: true, state: state)
+          allow(shipment).to receive_messages(state: state)
         end
 
         it "finalizes adjustments" do
@@ -760,8 +761,12 @@ RSpec.describe Spree::Shipment, type: :model do
   describe "#finalize!" do
     let(:inventory_unit) { shipment.inventory_units.first }
     let(:stock_item) { inventory_unit.variant.stock_items.find_by(stock_location: stock_location) }
+    let(:inventory_unit_finalizer) { double(:inventory_unit_finalizer, run!: [true]) }
 
     before do
+      allow(Spree::Stock::InventoryUnitsFinalizer)
+        .to receive(:new).and_return(inventory_unit_finalizer)
+
       stock_item.set_count_on_hand(10)
       stock_item.update_attributes!(backorderable: false)
       inventory_unit.update_attributes!(pending: true)
@@ -769,18 +774,20 @@ RSpec.describe Spree::Shipment, type: :model do
 
     subject { shipment.finalize! }
 
-    it "updates the associated inventory units" do
-      inventory_unit.update_columns(updated_at: 1.hour.ago)
-      expect { subject }.to change { inventory_unit.reload.updated_at }
-    end
+    it "call run! on Spree::Stock::InventoryUnitsFinalizer" do
+      expect(inventory_unit_finalizer).to receive(:run!)
 
-    it "unstocks the variant" do
-      expect { subject }.to change { stock_item.reload.count_on_hand }.from(10).to(9)
+      subject
     end
 
     context "inventory unit already finalized" do
-      before do
-        inventory_unit.update_attributes!(pending: false)
+      let(:inventory_unit) { build(:inventory_unit, pending: false) }
+
+      it "doesn't pass the inventory unit" do
+        expect(Spree::Stock::InventoryUnitsFinalizer)
+          .to receive(:new).with([])
+
+        subject
       end
 
       it "doesn't update the associated inventory units" do

data/spec/models/spree/shipping_calculator_spec.rb

@@ -4,11 +4,21 @@ require 'rails_helper'
 
 module Spree
   RSpec.describe ShippingCalculator, type: :model do
-    let(:variant1) { build(:variant, price: 10) }
-    let(:variant2) { build(:variant, price: 20) }
+    let(:line_item1) { build(:line_item, price: 10) }
+    let(:line_item2) { build(:line_item, price: 20) }
+
+    let(:inventory_unit1) { build(:inventory_unit, line_item: line_item1) }
+    let(:inventory_unit2) { build(:inventory_unit, line_item: line_item2) }
 
     let(:package) do
-      build(:stock_package, variants_contents: { variant1 => 2, variant2 => 1 })
+      build(
+        :stock_package,
+        contents: [
+          Spree::Stock::ContentItem.new(inventory_unit1),
+          Spree::Stock::ContentItem.new(inventory_unit1),
+          Spree::Stock::ContentItem.new(inventory_unit2)
+        ]
+      )
     end
 
     subject { ShippingCalculator.new }

data/spec/models/spree/stock/allocator/on_hand_first_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  module Stock
+    module Allocator
+      RSpec.describe OnHandFirst, type: :model do
+        subject { described_class.new(availability) }
+
+        let(:availability) { double(Spree::Stock::Availability) }
+
+        let!(:default_stock_location) { create(:stock_location, default: true, backorderable_default: false) }
+        let!(:backorderable_stock_location) { create(:stock_location) }
+
+        let(:first_variant) { create(:variant) }
+        let(:second_variant) { create(:variant) }
+
+        let(:desired_quantities) do
+          quantities = {}
+          quantities[first_variant] = first_variant_desired
+          quantities[second_variant] = second_variant_desired
+          quantities
+        end
+
+        let(:desired) { Spree::StockQuantities.new(desired_quantities) }
+
+        describe '#allocate_inventory' do
+          let(:default_on_hand_availability) do
+            quantities = {}
+            quantities[first_variant] = first_variant_default_availability
+            quantities[second_variant] = second_variant_default_availability
+            quantities
+          end
+
+          let(:dropship_on_hand_availability) do
+            quantities = {}
+            quantities[first_variant] = first_variant_dropship_availability
+            quantities[second_variant] = second_variant_dropship_availability
+            quantities
+          end
+
+          let(:on_hand_by_stock_location_id) do
+            availability = {}
+            availability[default_stock_location.id] = Spree::StockQuantities.new(default_on_hand_availability)
+            availability[backorderable_stock_location.id] = Spree::StockQuantities.new(dropship_on_hand_availability)
+            availability
+          end
+
+          let(:dropship_backorderable_availability) do
+            quantities = {}
+            quantities[first_variant] = Float::INFINITY
+            quantities[second_variant] = Float::INFINITY
+            quantities
+          end
+
+          let(:backorderable_by_stock_location_id) do
+            availability = {}
+            availability[backorderable_stock_location.id] = Spree::StockQuantities.new(dropship_backorderable_availability)
+            availability
+          end
+
+          before do
+            allow(availability).to receive(:on_hand_by_stock_location_id)
+              .and_return(on_hand_by_stock_location_id)
+
+            allow(availability).to receive(:backorderable_by_stock_location_id)
+              .and_return(backorderable_by_stock_location_id)
+          end
+
+          context 'when default stock location has enough items' do
+            let(:first_variant_default_availability) { 100 }
+            let(:second_variant_default_availability) { 100 }
+            let(:first_variant_dropship_availability) { 0 }
+            let(:second_variant_dropship_availability) { 0 }
+            let(:first_variant_desired) { 30 }
+            let(:second_variant_desired) { 5 }
+
+            it 'allocates all the desired units on the default stock location' do
+              on_hand_packages, backordered_packages, leftover = subject.allocate_inventory(desired)
+
+              expect(on_hand_packages[default_stock_location.id][first_variant]).to eq(30)
+              expect(on_hand_packages[default_stock_location.id][second_variant]).to eq(5)
+              expect(on_hand_packages[backorderable_stock_location.id][first_variant]).to eq(0)
+              expect(on_hand_packages[backorderable_stock_location.id][second_variant]).to eq(0)
+
+              expect(backordered_packages[backorderable_stock_location.id][first_variant]).to eq(0)
+              expect(backordered_packages[backorderable_stock_location.id][second_variant]).to eq(0)
+
+              expect(leftover[first_variant]).to eq(0)
+              expect(leftover[second_variant]).to eq(0)
+            end
+          end
+
+          context 'when default stock location hasn\'t enough items' do
+            let(:first_variant_default_availability) { 10 }
+            let(:second_variant_default_availability) { 10 }
+
+            let(:first_variant_desired) { 15 }
+            let(:second_variant_desired) { 5 }
+
+            context 'when dropship stock location has enough items' do
+              let(:first_variant_dropship_availability) { 20 }
+              let(:second_variant_dropship_availability) { 0 }
+
+              it 'allocates all the desired units on the stock locations while stocks last' do
+                on_hand_packages, backordered_packages, leftover = subject.allocate_inventory(desired)
+
+                expect(on_hand_packages[default_stock_location.id][first_variant]).to eq(10)
+                expect(on_hand_packages[default_stock_location.id][second_variant]).to eq(5)
+                expect(on_hand_packages[backorderable_stock_location.id][first_variant]).to eq(5)
+                expect(on_hand_packages[backorderable_stock_location.id][second_variant]).to eq(0)
+
+                expect(backordered_packages[backorderable_stock_location.id][first_variant]).to eq(0)
+                expect(backordered_packages[backorderable_stock_location.id][second_variant]).to eq(0)
+
+                expect(leftover[first_variant]).to eq(0)
+                expect(leftover[second_variant]).to eq(0)
+              end
+            end
+
+            context 'when dropship stock location hasn\'t enough items' do
+              let(:first_variant_dropship_availability) { 2 }
+              let(:second_variant_dropship_availability) { 0 }
+
+              it 'allocates all the desired units on the stock locations while stocks last' do
+                on_hand_packages, backordered_packages, leftover = subject.allocate_inventory(desired)
+
+                expect(on_hand_packages[default_stock_location.id][first_variant]).to eq(10)
+                expect(on_hand_packages[default_stock_location.id][second_variant]).to eq(5)
+                expect(on_hand_packages[backorderable_stock_location.id][first_variant]).to eq(2)
+                expect(on_hand_packages[backorderable_stock_location.id][second_variant]).to eq(0)
+
+                expect(backordered_packages[backorderable_stock_location.id][first_variant]).to eq(3)
+                expect(backordered_packages[backorderable_stock_location.id][second_variant]).to eq(0)
+
+                expect(leftover[first_variant]).to eq(0)
+                expect(leftover[second_variant]).to eq(0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/stock/content_item_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  module Stock
+    RSpec.describe ContentItem, type: :model do
+      let(:instance) { ContentItem.new(inventory_unit, state) }
+      let(:inventory_unit) { build(:inventory_unit) }
+      let(:state) { :on_hand }
+
+      describe '#variant' do
+        subject { instance.variant }
+        it { is_expected.to eq(inventory_unit.variant) }
+      end
+
+      describe '#weight' do
+        subject { instance.weight }
+        it { is_expected.to eq(0.to_d) }
+      end
+
+      describe '#line_item' do
+        subject { instance.line_item }
+        it { is_expected.to eq(inventory_unit.line_item) }
+      end
+
+      describe '#on_hand?' do
+        subject { instance.on_hand? }
+
+        context 'the state is on hand' do
+          it { is_expected.to eq(true) }
+        end
+
+        context 'the state is not on hand' do
+          let(:state) { 'foo' }
+          it { is_expected.to eq(false) }
+        end
+      end
+
+      describe '#backordered?' do
+        subject { instance.backordered? }
+
+        context 'the state is not backordered' do
+          let(:state) { 'foo' }
+          it { is_expected.to eq(false) }
+        end
+
+        context 'the state is backordered' do
+          let(:state) { :backordered }
+          it { is_expected.to eq(true) }
+        end
+      end
+
+      describe '#price' do
+        subject { instance.price }
+        it { is_expected.to eq(10.to_d) }
+      end
+
+      describe '#amount' do
+        subject { instance.amount }
+        it { is_expected.to eq(10.to_d) }
+      end
+
+      describe '#quantity' do
+        subject { instance.quantity }
+        it { is_expected.to eq(1) }
+      end
+    end
+  end
+end

data/spec/models/spree/stock/estimator_spec.rb

@@ -205,11 +205,14 @@ module Spree
         end
 
         it 'uses the configured shipping rate sorter' do
-          class Spree::Stock::TestSorter; end;
+          class Spree::Stock::TestSorter
+            def initialize(_rates)
+            end
+          end
           Spree::Config.shipping_rate_sorter_class = Spree::Stock::TestSorter
 
           sorter = double(:sorter, sort: nil)
-          allow(Spree::Stock::TestSorter).to receive(:new).and_return(sorter)
+          allow(Spree::Stock::TestSorter).to receive(:new) { sorter }
 
           subject.shipping_rates(package)
 

data/spec/models/spree/stock/inventory_units_finalizer_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  module Stock
+    RSpec.describe InventoryUnitsFinalizer, type: :model do
+      let(:order)          { build(:order_with_line_items) }
+      let(:inventory_unit) { build(:inventory_unit, order: order, variant: order.line_items.first.variant, shipment: order.shipments.first) }
+      let(:stock_item) { inventory_unit.variant.stock_items.first }
+
+      before do
+        stock_item.set_count_on_hand(10)
+        stock_item.update_attributes!(backorderable: false)
+        inventory_unit.update_attributes!(pending: true)
+      end
+
+      subject { described_class.new([inventory_unit]).run! }
+
+      it "updates the associated inventory units" do
+        inventory_unit.update_columns(updated_at: 1.hour.ago)
+        expect { subject }.to change { inventory_unit.reload.updated_at }
+      end
+
+      it "updates the inventory units to not be pending" do
+        expect { subject }.to change { inventory_unit.reload.pending }.to(false)
+      end
+
+      it "unstocks the variant" do
+        expect { subject }.to change { stock_item.reload.count_on_hand }.from(10).to(9)
+      end
+    end
+  end
+end