solidus_core 2.9.6 → 2.10.3

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

@@ -57,14 +57,14 @@ module Spree
       context "multiple payment methods" do
         let(:simulate) { true }
         let!(:check_payment) { create(:check_payment, order: reimbursement.order, amount: 5.0, state: "completed") }
-        let(:payment) { reimbursement.order.payments.detect { |p| p.payment_method.is_a? Spree::PaymentMethod::BogusCreditCard } }
+        let(:payment) { reimbursement.order.payments.detect { |item| item.payment_method.is_a? Spree::PaymentMethod::BogusCreditCard } }
         let(:refund_amount) { 10.0 }
 
         let(:refund_payment_methods) { subject.map { |refund| refund.payment.payment_method } }
 
         before do
-          reimbursement.order.payments.first.update_attributes!(amount: 5.0)
-          return_item.update_attributes!(amount: refund_amount)
+          reimbursement.order.payments.first.update!(amount: 5.0)
+          return_item.update!(amount: refund_amount)
         end
 
         it "includes refunds all payment type" do

data/spec/models/spree/return_item/exchange_variant_eligibility/same_product_spec.rb

@@ -18,7 +18,7 @@ module Spree
         context "product has variants" do
           it "returns all variants for the same product" do
             product = create(:product, variants: Array.new(3) { create(:variant) })
-            product.variants.map { |v| v.stock_items.first.update_column(:count_on_hand, 10) }
+            product.variants.map { |value| value.stock_items.first.update_column(:count_on_hand, 10) }
 
             expect(SameProduct.eligible_variants(product.variants.first).sort).to eq product.variants.sort
           end

data/spec/models/spree/return_item_spec.rb

@@ -26,8 +26,8 @@ RSpec.describe Spree::ReturnItem, type: :model do
     let(:return_item) { create(:return_item, inventory_unit: inventory_unit) }
 
     before do
-      inventory_unit.update_attributes!(state: 'shipped')
-      return_item.update_attributes!(reception_status: 'awaiting')
+      inventory_unit.update!(state: 'shipped')
+      return_item.update!(reception_status: 'awaiting')
       allow(return_item).to receive(:eligible_for_return?).and_return(true)
     end
 
@@ -91,9 +91,9 @@ RSpec.describe Spree::ReturnItem, type: :model do
       let(:stock_item) { stock_location.stock_item(inventory_unit.variant) }
 
       before do
-        inventory_unit.update_attributes!(state: 'shipped')
-        return_item.update_attributes!(reception_status: 'awaiting')
-        stock_location.update_attributes!(restock_inventory: true)
+        inventory_unit.update!(state: 'shipped')
+        return_item.update!(reception_status: 'awaiting')
+        stock_location.update!(restock_inventory: true)
       end
 
       it 'increases the count on hand' do
@@ -102,9 +102,9 @@ RSpec.describe Spree::ReturnItem, type: :model do
 
       context 'when variant does not track inventory' do
         before do
-          inventory_unit.update_attributes!(state: 'shipped')
-          inventory_unit.variant.update_attributes!(track_inventory: false)
-          return_item.update_attributes!(reception_status: 'awaiting')
+          inventory_unit.update!(state: 'shipped')
+          inventory_unit.variant.update!(track_inventory: false)
+          return_item.update!(reception_status: 'awaiting')
         end
 
         it 'does not increase the count on hand' do
@@ -114,7 +114,7 @@ RSpec.describe Spree::ReturnItem, type: :model do
 
       context "when the stock location's restock_inventory is false" do
         before do
-          stock_location.update_attributes!(restock_inventory: false)
+          stock_location.update!(restock_inventory: false)
         end
 
         it 'does not increase the count on hand' do
@@ -135,7 +135,7 @@ RSpec.describe Spree::ReturnItem, type: :model do
 
       Spree::ReturnItem::INTERMEDIATE_RECEPTION_STATUSES.each do |status|
         context "when the item was #{status}" do
-          before { return_item.update_attributes!(reception_status: status) }
+          before { return_item.update!(reception_status: status) }
 
           it 'processes the inventory unit' do
             subject
@@ -293,7 +293,7 @@ RSpec.describe Spree::ReturnItem, type: :model do
       subject { return_item.public_send("#{transition}!") }
       context "awaiting status" do
         before do
-          return_item.update_attributes!(reception_status: 'awaiting')
+          return_item.update!(reception_status: 'awaiting')
           allow(return_item).to receive(:eligible_for_return?).and_return(true)
         end
 

data/spec/models/spree/returns_calculator_spec.rb

@@ -5,9 +5,9 @@ require 'rails_helper'
 module Spree
   RSpec.describe ReturnsCalculator, type: :model do
     let(:return_item) { build(:return_item) }
-    subject { ReturnsCalculator.new }
+    subject { described_class.new }
 
-    it 'compute_shipment must be overridden' do
+    it 'compute must be overridden' do
       expect {
         subject.compute(return_item)
       }.to raise_error NotImplementedError

data/spec/models/spree/shipment_spec.rb

@@ -152,7 +152,7 @@ RSpec.describe Spree::Shipment, type: :model do
 
   describe '#total_before_tax' do
     before do
-      shipment.update_attributes!(cost: 10)
+      shipment.update!(cost: 10)
     end
     let!(:admin_adjustment) { create(:adjustment, adjustable: shipment, order: shipment.order, amount: -1, source: nil) }
     let!(:promo_adjustment) { create(:adjustment, adjustable: shipment, order: shipment.order, amount: -2, source: promo_action) }
@@ -250,7 +250,7 @@ RSpec.describe Spree::Shipment, type: :model do
       end
 
       it "can't get rates without a shipping address" do
-        shipment.order.update_attributes!(ship_address: nil)
+        shipment.order.update!(ship_address: nil)
         expect(shipment.refresh_rates).to eq([])
       end
 
@@ -298,7 +298,7 @@ RSpec.describe Spree::Shipment, type: :model do
     shared_examples_for "pending if backordered" do
       it "should have a state of pending if backordered" do
         # Set as ready so we can test for change
-        shipment.update_attributes!(state: 'ready')
+        shipment.update!(state: 'ready')
 
         allow(shipment).to receive_messages(inventory_units: [mock_model(Spree::InventoryUnit, allow_ship?: false, canceled?: false, shipped?: false)])
         expect(shipment).to receive(:update_columns).with(state: 'pending', updated_at: kind_of(Time))
@@ -310,7 +310,7 @@ RSpec.describe Spree::Shipment, type: :model do
       before { allow(order).to receive_messages can_ship?: false }
       it "should result in a 'pending' state" do
         # Set as ready so we can test for change
-        shipment.update_attributes!(state: 'ready')
+        shipment.update!(state: 'ready')
         expect(shipment).to receive(:update_columns).with(state: 'pending', updated_at: kind_of(Time))
         shipment.update_state
       end
@@ -768,8 +768,8 @@ RSpec.describe Spree::Shipment, type: :model do
         .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)
+      stock_item.update!(backorderable: false)
+      inventory_unit.update!(pending: true)
     end
 
     subject { shipment.finalize! }

data/spec/models/spree/shipping_calculator_spec.rb

@@ -21,25 +21,13 @@ module Spree
       )
     end
 
-    subject { ShippingCalculator.new }
-
-    it 'computes with a shipment' do
-      shipment = mock_model(Spree::Shipment)
-      expect(subject).to receive(:compute_shipment).with(shipment)
-      subject.compute(shipment)
-    end
+    subject { described_class.new }
 
     it 'computes with a package' do
       expect(subject).to receive(:compute_package).with(package)
       subject.compute(package)
     end
 
-    it 'compute_shipment must be overridden' do
-      expect {
-        subject.compute_shipment(shipment)
-      }.to raise_error NameError
-    end
-
     it 'compute_package must be overridden' do
       expect {
         subject.compute_package(package)

data/spec/models/spree/shipping_method_spec.rb

@@ -257,4 +257,36 @@ RSpec.describe Spree::ShippingMethod, type: :model do
       it { should == 'back_end' }
     end
   end
+
+  describe '.available_to_store' do
+    let(:store) { create(:store) }
+    let(:first_shipping_method) { create(:shipping_method, stores: [store]) }
+    let(:second_shipping_method) { create(:shipping_method, stores: [store]) }
+
+    subject { [first_shipping_method, second_shipping_method] }
+
+    it 'raises an exception if no store is passed as argument' do
+      expect {
+        described_class.available_to_store(nil)
+      }.to raise_exception(ArgumentError, 'You must provide a store')
+    end
+
+    context 'when the store has no shipping methods associated' do
+      before { store.shipping_methods = [] }
+
+      it 'returns all shipping methods' do
+        expect(store.shipping_methods).to eq([])
+        expect(described_class.available_to_store(store)).to eq(subject)
+      end
+    end
+
+    context 'when the store has shipping methods associated' do
+      before { create(:shipping_method) }
+
+      it 'returns the associated records' do
+        expect(store.shipping_methods).to eq(subject)
+        expect(described_class.available_to_store(store)).to eq(subject)
+      end
+    end
+  end
 end

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

@@ -115,8 +115,8 @@ module Spree
         let(:stock_location) { order.shipments.first.stock_location }
 
         before do
-          shipment2 = order.shipments.create!(stock_location: order.shipments.first.stock_location)
-          order.contents.add(variant, 1, shipment: shipment2)
+          shipment_two = order.shipments.create!(stock_location: order.shipments.first.stock_location)
+          order.contents.add(variant, 1, shipment: shipment_two)
           variant.stock_items.first.update_columns(count_on_hand: count_on_hand, backorderable: false)
         end
 

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

@@ -19,11 +19,11 @@ module Spree
       let(:order) { mock_model(Order, line_items: [line_item1, line_item2]) }
 
       let(:package1) do
-        Package.new(stock_location).tap { |p| p.add(inventory_unit1) }
+        Package.new(stock_location).tap { |package| package.add(inventory_unit1) }
       end
 
       let(:package2) do
-        Package.new(stock_location).tap { |p| p.add(inventory_unit2) }
+        Package.new(stock_location).tap { |package| package.add(inventory_unit2) }
       end
 
       let(:packages) { [package1, package2] }

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

@@ -8,8 +8,8 @@ module Spree
       let(:shipping_rate) { 4.00 }
       let!(:shipping_method) { create(:shipping_method, cost: shipping_rate, currency: currency) }
       let(:package) do
-        build(:stock_package, contents: inventory_units.map { |i| ContentItem.new(i) }).tap do |p|
-          p.shipment = p.to_shipment
+        build(:stock_package, contents: inventory_units.map { |unit| ContentItem.new(unit) }).tap do |package|
+          package.shipment = package.to_shipment
         end
       end
       let(:order) { create(:order_with_line_items, shipping_method: shipping_method) }
@@ -61,7 +61,7 @@ module Spree
         end
 
         context "when the order's ship address is in a different zone" do
-          before { shipping_method.zones.each{ |z| z.members.delete_all } }
+          before { shipping_method.zones.each{ |zone| zone.members.delete_all } }
           it_should_behave_like "shipping rate doesn't match"
         end
 

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

@@ -12,8 +12,8 @@ module Spree
 
         before do
           stock_item.set_count_on_hand(10)
-          stock_item.update_attributes!(backorderable: false)
-          inventory_unit.update_attributes!(pending: true)
+          stock_item.update!(backorderable: false)
+          inventory_unit.update!(pending: true)
         end
 
         subject { described_class.new([inventory_unit]).run! }
@@ -42,8 +42,8 @@ module Spree
         before do
           stock_item.set_count_on_hand(10)
           stock_item_2.set_count_on_hand(10)
-          inventory_unit.update_attributes!(pending: true)
-          inventory_unit_2.update_attributes!(pending: true)
+          inventory_unit.update!(pending: true)
+          inventory_unit_2.update!(pending: true)
         end
 
         subject { described_class.new([inventory_unit, inventory_unit_2]).run! }

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

@@ -51,41 +51,41 @@ module Spree
       end
 
       it 'builds the correct list of shipping methods based on stock location and categories' do
-        category1 = create(:shipping_category)
-        category2 = create(:shipping_category)
-        method1   = create(:shipping_method, available_to_all: true)
-        method2   = create(:shipping_method, stock_locations: [stock_location])
-        method1.shipping_categories = [category1, category2]
-        method2.shipping_categories = [category1, category2]
-        variant1 = mock_model(Variant, shipping_category_id: category1.id)
-        variant2 = mock_model(Variant, shipping_category_id: category2.id)
-        variant3 = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant2)),
-                    ContentItem.new(build(:inventory_unit, variant: variant3))]
+        category_one = create(:shipping_category)
+        category_two = create(:shipping_category)
+        method_one   = create(:shipping_method, available_to_all: true)
+        method_two   = create(:shipping_method, stock_locations: [stock_location])
+        method_one.shipping_categories = [category_one, category_two]
+        method_two.shipping_categories = [category_one, category_two]
+        variant_one = mock_model(Variant, shipping_category_id: category_one.id)
+        variant_two = mock_model(Variant, shipping_category_id: category_two.id)
+        variant_three = mock_model(Variant, shipping_category_id: nil)
+        contents = [ContentItem.new(build(:inventory_unit, variant: variant_one)),
+                    ContentItem.new(build(:inventory_unit, variant: variant_one)),
+                    ContentItem.new(build(:inventory_unit, variant: variant_two)),
+                    ContentItem.new(build(:inventory_unit, variant: variant_three))]
 
         package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to match_array([method1, method2])
+        expect(package.shipping_methods).to match_array([method_one, method_two])
       end
       # Contains regression test for https://github.com/spree/spree/issues/2804
       it 'builds a list of shipping methods common to all categories' do
-        category1 = create(:shipping_category)
-        category2 = create(:shipping_category)
-        method1   = create(:shipping_method)
-        method2   = create(:shipping_method)
-        method1.shipping_categories = [category1, category2]
-        method2.shipping_categories = [category1]
-        variant1 = mock_model(Variant, shipping_category_id: category1.id)
-        variant2 = mock_model(Variant, shipping_category_id: category2.id)
-        variant3 = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant2)),
-                    ContentItem.new(build(:inventory_unit, variant: variant3))]
+        category_one = create(:shipping_category)
+        category_two = create(:shipping_category)
+        method_one   = create(:shipping_method)
+        method_two   = create(:shipping_method)
+        method_one.shipping_categories = [category_one, category_two]
+        method_two.shipping_categories = [category_one]
+        variant_one = mock_model(Variant, shipping_category_id: category_one.id)
+        variant_two = mock_model(Variant, shipping_category_id: category_two.id)
+        variant_three = mock_model(Variant, shipping_category_id: nil)
+        contents = [ContentItem.new(build(:inventory_unit, variant: variant_one)),
+                    ContentItem.new(build(:inventory_unit, variant: variant_one)),
+                    ContentItem.new(build(:inventory_unit, variant: variant_two)),
+                    ContentItem.new(build(:inventory_unit, variant: variant_three))]
 
         package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to match_array([method1])
+        expect(package.shipping_methods).to match_array([method_one])
       end
 
       it 'builds an empty list of shipping methods when no categories' do

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

@@ -49,7 +49,7 @@ module Spree
         end
 
         context 'when stock item prevents backordering' do
-          before { stock_item.update_attributes(backorderable: false) }
+          before { stock_item.update(backorderable: false) }
 
           specify { expect(subject.backorderable?).to be false }
 
@@ -81,7 +81,7 @@ module Spree
         end
 
         context 'when all stock items prevent backordering' do
-          before { stock_item.update_attributes(backorderable: false) }
+          before { stock_item.update(backorderable: false) }
 
           specify { expect(subject.backorderable?).to be false }
 

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

@@ -90,8 +90,8 @@ module Spree
 
           expect(shipments.size).to eq 2
 
-          location_1_shipment = shipments.detect { |p| p.stock_location == stock_location_1 }
-          location_2_shipment = shipments.detect { |p| p.stock_location == stock_location_2 }
+          location_1_shipment = shipments.detect { |shipment| shipment.stock_location == stock_location_1 }
+          location_2_shipment = shipments.detect { |shipment| shipment.stock_location == stock_location_2 }
 
           expect(location_1_shipment).to be_present
           expect(location_2_shipment).to be_present
@@ -107,8 +107,8 @@ module Spree
         let!(:variant) { create(:variant, track_inventory: true) }
 
         before do
-          stock_item1 = variant.stock_items.create!(stock_location: stock_location_1, backorderable: false)
-          stock_item1.set_count_on_hand(location_1_inventory)
+          stock_item_one = variant.stock_items.create!(stock_location: stock_location_1, backorderable: false)
+          stock_item_one.set_count_on_hand(location_1_inventory)
         end
 
         let!(:order) { create(:order) }
@@ -119,7 +119,7 @@ module Spree
         shared_examples "a fulfillable package" do
           it "packages correctly" do
             expect(shipments).not_to be_empty
-            inventory_units = shipments.flat_map { |s| s.inventory_units }
+            inventory_units = shipments.flat_map { |shipment| shipment.inventory_units }
             expect(inventory_units.size).to eq(5)
             expect(inventory_units.uniq.size).to eq(5)
           end
@@ -157,8 +157,8 @@ module Spree
         context 'with two stock locations' do
           let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
           before do
-            stock_item2 = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
-            stock_item2.set_count_on_hand(location_2_inventory)
+            stock_item_two = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
+            stock_item_two.set_count_on_hand(location_2_inventory)
           end
 
           context "with no inventory" do
@@ -214,11 +214,11 @@ module Spree
           let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
           let!(:stock_location_3) { create(:stock_location, propagate_all_variants: false, active: true) }
           before do
-            stock_item2 = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
-            stock_item2.set_count_on_hand(location_2_inventory)
+            stock_item_two = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
+            stock_item_two.set_count_on_hand(location_2_inventory)
 
-            stock_item3 = variant.stock_items.create!(stock_location: stock_location_3, backorderable: false)
-            stock_item3.set_count_on_hand(location_3_inventory)
+            stock_item_three = variant.stock_items.create!(stock_location: stock_location_3, backorderable: false)
+            stock_item_three.set_count_on_hand(location_3_inventory)
           end
 
           # Regression test for https://github.com/solidusio/solidus/issues/2122

data/spec/models/spree/stock/splitter/base_spec.rb

@@ -9,12 +9,12 @@ module Spree
         let(:stock_location) { mock_model(Spree::StockLocation) }
 
         it 'continues to splitter chain' do
-          splitter1 = Base.new(stock_location)
-          splitter2 = Base.new(stock_location, splitter1)
+          splitter_one = Base.new(stock_location)
+          splitter_two = Base.new(stock_location, splitter_one)
           packages = []
 
-          expect(splitter1).to receive(:split).with(packages)
-          splitter2.split(packages)
+          expect(splitter_one).to receive(:split).with(packages)
+          splitter_two.split(packages)
         end
       end
     end

data/spec/models/spree/stock/splitter/shipping_category_spec.rb

@@ -29,15 +29,15 @@ module Spree
       subject { described_class.new(stock_location) }
 
       it 'splits each package by shipping category' do
-        package1 = Package.new(stock_location)
-        4.times { package1.add inventory_unit1 }
-        8.times { package1.add inventory_unit2 }
+        package_one = Package.new(stock_location)
+        4.times { package_one.add inventory_unit1 }
+        8.times { package_one.add inventory_unit2 }
 
-        package2 = Package.new(stock_location)
-        6.times { package2.add inventory_unit1 }
-        9.times { package2.add inventory_unit2, :backordered }
+        package_two = Package.new(stock_location)
+        6.times { package_two.add inventory_unit1 }
+        9.times { package_two.add inventory_unit2, :backordered }
 
-        packages = subject.split([package1, package2])
+        packages = subject.split([package_one, package_two])
         expect(packages[0].quantity).to eq 4
         expect(packages[1].quantity).to eq 8
         expect(packages[2].quantity).to eq 6