solidus_core 2.10.0.beta1 → 2.10.0

data/spec/models/spree/promotion_rule_spec.rb

@@ -17,13 +17,13 @@ module Spree
     end
 
     it "validates unique rules for a promotion" do
-      p1 = TestRule.new
-      p1.promotion_id = 1
-      p1.save
+      promotion_one = TestRule.new
+      promotion_one.promotion_id = 1
+      promotion_one.save
 
-      p2 = TestRule.new
-      p2.promotion_id = 1
-      expect(p2).not_to be_valid
+      promotion_two = TestRule.new
+      promotion_two.promotion_id = 1
+      expect(promotion_two).not_to be_valid
     end
 
     it "generates its own partial path" do

data/spec/models/spree/promotion_spec.rb

@@ -434,12 +434,12 @@ RSpec.describe Spree::Promotion, type: :model do
     end
 
     context 'when expires_at date is not already reached' do
-      let(:expires_at) { Time.current + 1.days }
+      let(:expires_at) { Time.current + 1.day }
       it { is_expected.to be_falsey }
     end
 
     context 'when expires_at date is in the past' do
-      let(:expires_at) { Time.current - 1.days }
+      let(:expires_at) { Time.current - 1.day }
       it { is_expected.to be_truthy }
     end
   end
@@ -454,12 +454,12 @@ RSpec.describe Spree::Promotion, type: :model do
     end
 
     context 'when expires_at date is not already reached' do
-      let(:expires_at) { Time.current + 1.days }
+      let(:expires_at) { Time.current + 1.day }
       it { is_expected.to be_truthy }
     end
 
     context 'when expires_at date is in the past' do
-      let(:expires_at) { Time.current - 1.days }
+      let(:expires_at) { Time.current - 1.day }
       it { is_expected.to be_falsey }
     end
   end
@@ -569,76 +569,69 @@ RSpec.describe Spree::Promotion, type: :model do
 
   context "#eligible?" do
     subject do
-      promotion.eligible?(promotable)
+      promotion.eligible?(promotable, promotion_code: promotion.codes.first)
     end
 
-    let(:promotable) { create :order }
+    shared_examples "a promotable" do
+      context "when empty" do
+        it { is_expected.to be true }
+      end
 
-    it { is_expected.to be true }
+      context "when promotion is expired" do
+        before { promotion.expires_at = Time.current - 10.days }
 
-    context "when promotion is expired" do
-      before { promotion.expires_at = Time.current - 10.days }
-      it { is_expected.to be false }
-    end
+        it { is_expected.to be false }
+      end
 
-    context "when the promotion's usage limit is exceeded" do
-      let(:promotion) { FactoryBot.create(:promotion, :with_order_adjustment) }
+      context "when promotion's usage limit is exceeded" do
+        before do
+          promotion.usage_limit = 1
+          create(:completed_order_with_promotion, promotion: promotion)
+        end
 
-      before do
-        FactoryBot.create(
-          :completed_order_with_promotion,
-          promotion: promotion
-        )
-        promotion.usage_limit = 1
+        it { is_expected.to be false }
       end
 
-      it "returns false" do
-        expect(promotion.eligible?(promotable)).to eq(false)
+      context "when promotion code's usage limit is exceeded" do
+        before do
+          promotion.per_code_usage_limit = 1
+          create(:completed_order_with_promotion, promotion: promotion)
+          promotion.codes.first.adjustments.update_all(eligible: true)
+        end
+
+        it { is_expected.to be false }
       end
-    end
 
-    context "when the promotion code's usage limit is exceeded" do
-      let(:promotion) { create(:promotion, :with_order_adjustment, code: 'abc123', per_code_usage_limit: 1) }
-      let(:promotion_code) { promotion.codes.first }
+      context "when promotion is at last usage on the same order" do
+        let(:order) { create(:completed_order_with_promotion, promotion: promotion) }
+        let(:promotable) { order }
 
-      before do
-        FactoryBot.create(
-          :completed_order_with_promotion,
-          promotion: promotion
-        )
-        promotion_code.adjustments.update_all(eligible: true)
-      end
+        before do
+          promotion.usage_limit = 1
+        end
 
-      it "returns false" do
-        expect(promotion.eligible?(promotable, promotion_code: promotion_code)).to eq(false)
+        it { is_expected.to be true }
       end
-    end
 
-    context "when promotable is a Spree::LineItem" do
-      let(:promotable) { create :line_item }
-      let(:product) { promotable.product }
+      context "when promotion code is at last usage on the same order" do
+        let(:order) { create(:completed_order_with_promotion, promotion: promotion) }
+        let(:promotable) { order }
 
-      before do
-        product.promotionable = promotionable
-      end
+        before do
+          promotion.per_code_usage_limit = 1
+        end
 
-      context "and product is promotionable" do
-        let(:promotionable) { true }
         it { is_expected.to be true }
       end
-
-      context "and product is not promotionable" do
-        let(:promotionable) { false }
-        it { is_expected.to be false }
-      end
     end
 
     context "when promotable is a Spree::Order" do
-      context "and it is empty" do
-        it { is_expected.to be true }
-      end
+      let(:promotion) { create(:promotion, :with_order_adjustment) }
+      let(:promotable) { create :order }
 
-      context "and it contains items" do
+      it_behaves_like "a promotable"
+
+      context "when it contains items" do
         let!(:line_item) { create(:line_item, order: promotable) }
         let!(:line_item2) { create(:line_item, order: promotable) }
 
@@ -646,6 +639,7 @@ RSpec.describe Spree::Promotion, type: :model do
           before do
             line_item.product.update_column(:promotionable, false)
           end
+
           it { is_expected.to be false }
         end
 
@@ -654,6 +648,7 @@ RSpec.describe Spree::Promotion, type: :model do
             line_item.product.update_column(:promotionable, false)
             line_item2.product.update_column(:promotionable, false)
           end
+
           it { is_expected.to be false }
         end
 
@@ -662,6 +657,32 @@ RSpec.describe Spree::Promotion, type: :model do
         end
       end
     end
+
+    context "when promotable is a Spree::LineItem" do
+      let(:promotion) { create(:promotion, :with_line_item_adjustment) }
+      let(:promotable) { create(:line_item) }
+
+      it_behaves_like "a promotable"
+
+      context "and product is promotionable" do
+        before { promotable.product.promotionable = true }
+
+        it { is_expected.to be true }
+      end
+
+      context "and product is not promotionable" do
+        before { promotable.product.promotionable = false }
+
+        it { is_expected.to be false }
+      end
+    end
+
+    context "when promotable is a Spree::Shipment" do
+      let(:promotion) { create(:promotion, :with_free_shipping) }
+      let(:promotable) { create(:shipment) }
+
+      it_behaves_like "a promotable"
+    end
   end
 
   context "#eligible_rules" do

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