solidus_core 2.10.0.beta1 → 2.10.5

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

@@ -57,7 +57,7 @@ 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 } }

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/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/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/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/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

data/spec/models/spree/stock_quantities_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Spree::StockQuantities, type: :model do
 
   describe "#each" do
     def expect_each
-      expect { |b| subject.each(&b) }
+      expect { |item| subject.each(&item) }
     end
 
     context "with no items" do

data/spec/models/spree/store_credit_spec.rb

@@ -777,7 +777,7 @@ RSpec.describe Spree::StoreCredit do
           let!(:store_credits) do
             [
               create(:store_credit, user: user, amount: store_credit_amount),
-              create(:store_credit, user: user, amount: additional_store_credit_amount)
+              create(:store_credit, user: user.reload, amount: additional_store_credit_amount)
             ]
           end
 

data/spec/models/spree/tax_rate_spec.rb

@@ -153,6 +153,7 @@ RSpec.describe Spree::TaxRate, type: :model do
 
     describe 'adjustments' do
       before do
+        expect(Spree::Deprecation).to receive(:warn)
         tax_rate.adjust(nil, item)
       end
 

data/spec/models/spree/taxons/paperclip_attachment_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe "Spree::Taxon::PaperclipAttachment", type: :model do
+  describe "#destroy_attachment" do
+    let(:taxon) { create(:taxon) }
+
+    context "when trying to destroy a valid attachment definition" do
+      context "and taxon has a file attached " do
+        it "removes the attachment" do
+          taxon.update(icon: File.new(Rails.root.join('..', '..', 'spec', 'fixtures', 'thinking-cat.jpg')))
+          expect(taxon.destroy_attachment(:icon)).to be_truthy
+        end
+      end
+      context "and the taxon does not have any file attached yet" do
+        it "returns false" do
+          expect(taxon.destroy_attachment(:icon)).to be_falsey
+        end
+      end
+    end
+
+    context "when trying to destroy an invalid attachment" do
+      it 'returns false' do
+        expect(taxon.destroy_attachment(:foo)).to be_falsey
+      end
+    end
+  end
+end

data/spec/models/spree/user_last_url_storer/rules/authentication_rule_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::UserLastUrlStorer::Rules::AuthenticationRule do
+  describe '#match?' do
+    let(:login_path) { '/sign_in' }
+    let(:request) { double(fullpath: fullpath) }
+    let(:controller) do
+      double(
+        request: request,
+        spree_login_path: login_path,
+        controller_name: 'controller_double'
+      )
+    end
+
+    subject { described_class.match?(controller) }
+
+    context 'when the request full path is an authentication route' do
+      let!(:fullpath) { login_path }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when the request full path is not an authentication route' do
+      let!(:fullpath) { '/products/baseball-cap' }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/models/spree/user_last_url_storer_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::UserLastUrlStorer do
+  subject { described_class.new(controller) }
+
+  let(:fullpath) { '/products/baseball-cap' }
+  let(:session) { {} }
+  let(:request) { double(fullpath: fullpath) }
+  let(:controller) do
+    instance_double(
+      ApplicationController,
+      request: request,
+      session: session,
+      controller_name: 'app_controller_double'
+    )
+  end
+
+  module CustomRule
+    def self.match?(_controller)
+      true
+    end
+  end
+
+  after :each do
+    described_class.rules.delete('CustomRule')
+  end
+
+  describe '::rules' do
+    it 'includes default rules' do
+      rule = Spree::UserLastUrlStorer::Rules::AuthenticationRule
+      expect(described_class.rules).to include(rule)
+    end
+
+    it 'can add new rules' do
+      described_class.rules << CustomRule
+      expect(described_class.rules).to include(CustomRule)
+    end
+  end
+
+  describe '#store_location' do
+    context 'when at least one rule matches' do
+      it 'does not set the path value into the session' do
+        described_class.rules << CustomRule
+        subject.store_location
+        expect(session[:spree_user_return_to]).to be_nil
+      end
+    end
+
+    context 'when no rule matches' do
+      it 'sets the path value into the session' do
+        described_class.rules << CustomRule
+        described_class.rules.delete('CustomRule')
+        subject.store_location
+        expect(session[:spree_user_return_to]).to eql fullpath
+      end
+    end
+  end
+end