solidus_core 2.9.5 → 2.10.2

data/spec/models/spree/promotion/rules/taxon_spec.rb

@@ -101,6 +101,7 @@ RSpec.describe Spree::Promotion::Rules::Taxon, type: :model do
         before do
           taxon.children << taxon2
           taxon.save!
+          taxon.reload
           product.taxons = [taxon2, taxon3]
           rule.taxons = [taxon, taxon3]
         end

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,80 +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(:order) { FactoryBot.create(:completed_order_with_promotion, promotion: promotion) }
-      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(:order) { FactoryBot.create(:completed_order_with_promotion, promotion: promotion) }
-      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
+      let(:promotion) { create(:promotion, :with_order_adjustment) }
       let(:promotable) { create :order }
 
-      context "and it is empty" do
-        it { is_expected.to be true }
-      end
+      it_behaves_like "a promotable"
 
-      context "and it contains items" do
+      context "when it contains items" do
         let!(:line_item) { create(:line_item, order: promotable) }
         let!(:line_item2) { create(:line_item, order: promotable) }
 
@@ -650,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
 
@@ -658,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
 
@@ -666,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,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