solidus_core 2.7.4 → 2.8.0

data/spec/models/spree/order_inventory_spec.rb

@@ -35,12 +35,19 @@ RSpec.describe Spree::OrderInventory, type: :model do
     end
 
     context "order is not completed" do
-      before { order.update_columns completed_at: nil }
+      let(:inventory_unit_finalizer) { double(:inventory_unit_finalizer, run!: [true]) }
 
-      it "doesn't unstock items" do
-        expect {
-          subject.verify(shipment)
-        }.not_to change { stock_item.reload.count_on_hand }
+      before do
+        allow(Spree::Stock::InventoryUnitsFinalizer)
+          .to receive(:new).and_return(inventory_unit_finalizer)
+
+        order.update_columns completed_at: nil
+      end
+
+      it "doesn't finalize the items" do
+        expect(inventory_unit_finalizer).to_not receive(:run!)
+
+        subject.verify(shipment)
       end
     end
 

data/spec/models/spree/order_merger_spec.rb

@@ -68,7 +68,6 @@ module Spree
     context "merging using extension-specific line_item_comparison_hooks" do
       before do
         Spree::Order.register_line_item_comparison_hook(:foos_match)
-        allow(Spree::Variant).to receive(:price_modifier_amount).and_return(0.00)
       end
 
       after do
@@ -83,7 +82,9 @@ module Spree
         end
 
         specify do
-          expect(order_1).to receive(:foos_match).with(@line_item_1, kind_of(Hash)).and_return(true)
+          without_partial_double_verification do
+            expect(order_1).to receive(:foos_match).with(@line_item_1, kind_of(Hash)).and_return(true)
+          end
           subject.merge!(order_2)
           expect(order_1.line_items.count).to eq(1)
 
@@ -95,7 +96,9 @@ module Spree
 
       context "2 different line items" do
         before do
-          allow(order_1).to receive(:foos_match).and_return(false)
+          without_partial_double_verification do
+            allow(order_1).to receive(:foos_match).and_return(false)
+          end
 
           order_1.contents.add(variant, 1, foos: {})
           order_2.contents.add(variant, 1, foos: { bar: :zoo })

data/spec/models/spree/order_spec.rb

@@ -15,10 +15,6 @@ RSpec.describe Spree::Order, type: :model do
   end
   let(:code) { promotion.codes.first }
 
-  before do
-    allow(Spree::LegacyUser).to receive_messages(current: mock_model(Spree::LegacyUser, id: 123))
-  end
-
   context '#store' do
     it { is_expected.to respond_to(:store) }
 
@@ -324,7 +320,7 @@ RSpec.describe Spree::Order, type: :model do
     end
   end
 
-  context "add_update_hook" do
+  context "add_update_hook", partial_double_verification: false do
     before do
       Spree::Order.class_eval do
         register_update_hook :add_awesome_sauce
@@ -712,7 +708,7 @@ RSpec.describe Spree::Order, type: :model do
       expect(order.find_line_item_by_variant(mock_model(Spree::Variant))).to be_nil
     end
 
-    context "match line item with options" do
+    context "match line item with options", partial_double_verification: false do
       before do
         Spree::Order.register_line_item_comparison_hook(:foos_match)
       end
@@ -1072,7 +1068,7 @@ RSpec.describe Spree::Order, type: :model do
 
     context 'an old-style refund exists' do
       let(:order) { create(:order_ready_to_ship) }
-      let(:payment) { order.payments.first.tap { |p| allow(p).to receive_messages(profiles_supported: false) } }
+      let(:payment) { order.payments.first.tap { |p| allow(p).to receive_messages(profiles_supported?: false) } }
       let!(:refund_payment) {
         build(:payment, amount: -1, order: order, state: 'completed', source: payment).tap do |p|
           allow(p).to receive_messages(profiles_supported?: false)

data/spec/models/spree/order_updater_spec.rb

@@ -513,15 +513,10 @@ module Spree
 
       it "doesnt update each shipment" do
         shipment = stub_model(Spree::Shipment)
-        shipments = [shipment]
-        allow(order).to receive_messages shipments: shipments
-        allow(shipments).to receive_messages states: []
-        allow(shipments).to receive_messages ready: []
-        allow(shipments).to receive_messages pending: []
-        allow(shipments).to receive_messages shipped: []
-
+        order.shipments = [shipment]
+        allow(order.shipments).to receive_messages(states: [], ready: [], pending: [], shipped: [])
         allow(updater).to receive(:update_totals) # Otherwise this gets called and causes a scene
-        expect(updater).not_to receive(:update_shipments).with(order)
+        expect(updater).not_to receive(:update_shipments)
         updater.update
       end
     end

data/spec/models/spree/payment/cancellation_spec.rb

@@ -63,14 +63,15 @@ RSpec.describe Spree::Payment::Cancellation do
       end
     end
 
-    context 'if the payment_method does not respond to `try_void`' do
+    context 'if the payment_method does not respond to `try_void`', partial_double_verification: false do
       before do
         allow(payment_method).to receive(:respond_to?) { false }
-        expect(payment_method).to receive(:cancel) { double }
-        expect(payment).to receive(:handle_void_response)
+        allow(payment_method).to receive(:cancel) { double }
+        allow(payment).to receive(:handle_void_response)
       end
 
       it 'calls cancel instead' do
+        expect(payment_method).to receive(:cancel)
         Spree::Deprecation.silence { subject }
       end
 

data/spec/models/spree/payment_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Spree::Payment, type: :model do
 
   let(:gateway) do
     gateway = Spree::PaymentMethod::BogusCreditCard.new(active: true, name: 'Bogus gateway')
-    allow(gateway).to receive_messages source_required: true
+    allow(gateway).to receive_messages(source_required?: true)
     gateway
   end
 
@@ -207,22 +207,6 @@ RSpec.describe Spree::Payment, type: :model do
         expect { payment.process! }.to raise_error(Spree::Core::GatewayError)
         expect(payment.state).to eq('invalid')
       end
-
-      # Regression test for https://github.com/spree/spree/issues/4598
-      it "should allow payments with a gateway_customer_profile_id" do
-        payment.source.update!(gateway_customer_profile_id: "customer_1", brand: 'visa')
-        expect(payment.payment_method.gateway_class).to receive(:supports?).with('visa').and_return(false)
-        expect(payment).to receive(:started_processing!)
-        payment.process!
-      end
-
-      # Another regression test for https://github.com/spree/spree/issues/4598
-      it "should allow payments with a gateway_payment_profile_id" do
-        payment.source.update!(gateway_payment_profile_id: "customer_1", brand: 'visa')
-        expect(payment.payment_method.gateway_class).to receive(:supports?).with('visa').and_return(false)
-        expect(payment).to receive(:started_processing!)
-        payment.process!
-      end
     end
 
     describe "#authorize!" do

data/spec/models/spree/permission_sets/promotion_management_spec.rb

@@ -16,6 +16,7 @@ RSpec.describe Spree::PermissionSets::PromotionManagement do
     it { is_expected.to be_able_to(:manage, Spree::PromotionRule) }
     it { is_expected.to be_able_to(:manage, Spree::PromotionAction) }
     it { is_expected.to be_able_to(:manage, Spree::PromotionCategory) }
+    it { is_expected.to be_able_to(:manage, Spree::PromotionCode) }
   end
 
   context "when not activated" do
@@ -23,5 +24,6 @@ RSpec.describe Spree::PermissionSets::PromotionManagement do
     it { is_expected.not_to be_able_to(:manage, Spree::PromotionRule) }
     it { is_expected.not_to be_able_to(:manage, Spree::PromotionAction) }
     it { is_expected.not_to be_able_to(:manage, Spree::PromotionCategory) }
+    it { is_expected.not_to be_able_to(:manage, Spree::PromotionCode) }
   end
 end

data/spec/models/spree/product_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe Spree::Product, type: :model do
         expect(clone.images.size).to eq(product.images.size)
       end
 
-      it 'calls #duplicate_extra' do
+      it 'calls #duplicate_extra', partial_double_verification: false do
         expect_any_instance_of(Spree::Product).to receive(:duplicate_extra) do |product, old_product|
           product.name = old_product.name.reverse
         end
@@ -572,4 +572,13 @@ RSpec.describe Spree::Product, type: :model do
       end
     end
   end
+
+  describe '#gallery' do
+    let(:product) { Spree::Product.new }
+    subject { product.gallery }
+
+    it 'responds to #images' do
+      expect(subject).to respond_to(:images)
+    end
+  end
 end

data/spec/models/spree/promotion_handler/coupon_spec.rb

@@ -42,18 +42,34 @@ module Spree
         end
 
         describe "#set_error_code" do
-          let(:status) { :coupon_code_not_found }
-
           subject { coupon.set_error_code status }
 
-          it 'should have status_code' do
-            subject
-            expect(coupon.status_code).to eq(status)
+          context 'not found' do
+            let(:status) { :coupon_code_not_found }
+
+            it 'has status_code' do
+              subject
+              expect(coupon.status_code).to eq(status)
+            end
+
+            it 'has error message' do
+              subject
+              expect(coupon.error).to eq(I18n.t(status, scope: 'spree'))
+            end
           end
 
-          it 'should have error message' do
-            subject
-            expect(coupon.error).to eq(I18n.t(status, scope: 'spree'))
+          context 'not present' do
+            let(:status) { :coupon_code_not_present }
+
+            it 'has status_code' do
+              subject
+              expect(coupon.status_code).to eq(status)
+            end
+
+            it 'has error message' do
+              subject
+              expect(coupon.error).to eq(I18n.t(status, scope: 'spree'))
+            end
           end
         end
       end
@@ -360,6 +376,44 @@ module Spree
           end
         end
       end
+
+      context 'removing a coupon code from an order' do
+        let!(:promotion) { promotion_code.promotion }
+        let(:promotion_code) { create(:promotion_code, value: '10off') }
+        let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
+        let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
+        let(:order) { create(:order_with_line_items, line_items_count: 3) }
+
+        context 'with an already applied coupon' do
+          before do
+            order.coupon_code = '10off'
+            subject.apply
+            order.reload
+            expect(order.total).to eq(100)
+          end
+
+          it 'successfully removes the coupon code from the order' do
+            subject.remove
+            expect(subject.error).to eq nil
+            expect(subject.success).to eq I18n.t('spree.coupon_code_removed')
+            expect(order.reload.total).to eq(130)
+          end
+        end
+
+        context 'with a coupon code not applied to an order' do
+          before do
+            order.coupon_code = '10off'
+            expect(order.total).to eq(130)
+          end
+
+          it 'returns an error' do
+            subject.remove
+            expect(subject.success).to eq nil
+            expect(subject.error).to eq I18n.t('spree.coupon_code_not_present')
+            expect(order.reload.total).to eq(130)
+          end
+        end
+      end
     end
   end
 end

data/spec/models/spree/promotion_spec.rb

@@ -49,6 +49,19 @@ RSpec.describe Spree::Promotion, type: :model do
     end
   end
 
+  describe ".coupons" do
+    let(:promotion_code) { create(:promotion_code) }
+    let!(:promotion_with_code) { promotion_code.promotion }
+    let!(:another_promotion_code) { create(:promotion_code, promotion: promotion_with_code) }
+    let!(:promotion_without_code) { create(:promotion) }
+
+    subject { described_class.coupons }
+
+    it "returns only distinct promotions with a code associated" do
+      expect(subject).to eq [promotion_with_code]
+    end
+  end
+
   describe "#apply_automatically" do
     subject { build(:promotion) }
 
@@ -632,15 +645,16 @@ RSpec.describe Spree::Promotion, type: :model do
     end
 
     context "with 'any' match policy" do
-      let(:promotion) { Spree::Promotion.create(name: "Promo", match_policy: 'any') }
       let(:promotable) { double('Promotable') }
 
+      before do
+        promotion.match_policy = 'any'
+      end
+
       it "should have eligible rules if any of the rules are eligible" do
-        allow_any_instance_of(Spree::PromotionRule).to receive_messages(applicable?: true)
-        true_rule = Spree::PromotionRule.create(promotion: promotion)
-        allow(true_rule).to receive_messages(eligible?: true)
-        allow(promotion).to receive_messages(rules: [true_rule])
-        allow(promotion).to receive_message_chain(:rules, :for).and_return([true_rule])
+        true_rule = mock_model(Spree::PromotionRule, eligible?: true, applicable?: true)
+        promotion.promotion_rules = [true_rule]
+        allow(promotion.rules).to receive(:for) { promotion.rules }
         expect(promotion.eligible_rules(promotable)).to eq [true_rule]
       end
 
@@ -668,13 +682,13 @@ RSpec.describe Spree::Promotion, type: :model do
   describe '#line_item_actionable?' do
     let(:order) { double Spree::Order }
     let(:line_item) { double Spree::LineItem }
-    let(:true_rule) { double Spree::PromotionRule, eligible?: true, applicable?: true, actionable?: true }
-    let(:false_rule) { double Spree::PromotionRule, eligible?: true, applicable?: true, actionable?: false }
+    let(:true_rule) { mock_model Spree::PromotionRule, eligible?: true, applicable?: true, actionable?: true }
+    let(:false_rule) { mock_model Spree::PromotionRule, eligible?: true, applicable?: true, actionable?: false }
     let(:rules) { [] }
 
     before do
-      allow(promotion).to receive(:rules) { rules }
-      allow(rules).to receive(:for) { rules }
+      promotion.promotion_rules = rules
+      allow(promotion.rules).to receive(:for) { rules }
     end
 
     subject { promotion.line_item_actionable? order, line_item }

data/spec/models/spree/refund_spec.rb

@@ -176,11 +176,12 @@ RSpec.describe Spree::Refund, type: :model do
     let(:customer_return) { reimbursement.customer_return }
     let(:reimbursement) { create(:reimbursement) }
     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::Refund.total_amount_reimbursed_for(reimbursement) }
 
     context 'with reimbursements performed' do
-      before { reimbursement.perform! }
+      before { reimbursement.perform!(created_by: created_by_user) }
 
       it 'returns the total amount' do
         amount = Spree::Refund.total_amount_reimbursed_for(reimbursement)

data/spec/models/spree/reimbursement_performer_spec.rb

@@ -7,25 +7,26 @@ RSpec.describe Spree::ReimbursementPerformer, type: :model do
   let(:return_item)             { reimbursement.return_items.first }
   let(:reimbursement_type)      { double("ReimbursementType") }
   let(:reimbursement_type_hash) { { reimbursement_type => [return_item] } }
+  let(:created_by_user) { create(:user, email: 'user@email.com') }
 
   before do
     expect(Spree::ReimbursementPerformer).to receive(:calculate_reimbursement_types).and_return(reimbursement_type_hash)
   end
 
   describe ".simulate" do
-    subject { Spree::ReimbursementPerformer.simulate(reimbursement) }
+    subject { Spree::ReimbursementPerformer.simulate(reimbursement, created_by: created_by_user) }
 
     it "reimburses each calculated reimbursement types with the correct return items as a simulation" do
-      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], true)
+      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], true, created_by: created_by_user)
       subject
     end
   end
 
   describe '.perform' do
-    subject { Spree::ReimbursementPerformer.perform(reimbursement) }
+    subject { Spree::ReimbursementPerformer.perform(reimbursement, created_by: created_by_user) }
 
     it "reimburses each calculated reimbursement types with the correct return items as a simulation" do
-      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], false)
+      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], false, created_by: created_by_user)
       subject
     end
   end

data/spec/models/spree/reimbursement_spec.rb

@@ -3,6 +3,28 @@
 require 'rails_helper'
 
 RSpec.describe Spree::Reimbursement, type: :model do
+  describe ".create" do
+    let(:customer_return) { create(:customer_return) }
+    let(:order) { customer_return.order }
+    let(:reimbursement) { build(:reimbursement, order: order) }
+
+    subject { reimbursement.save }
+
+    context "when total is not present" do
+      before do
+        allow(reimbursement).to receive(:calculated_total) { 100 }
+      end
+
+      it { expect { subject }.to change(reimbursement, :total).from(nil).to(100.0) }
+    end
+
+    context "when total is present" do
+      let(:reimbursement) { build(:reimbursement, order: order, total: 10) }
+
+      it { expect { subject }.not_to change(reimbursement, :total).from(10) }
+    end
+  end
+
   describe ".before_create" do
     describe "#generate_number" do
       context "number is assigned" do
@@ -66,8 +88,9 @@ RSpec.describe Spree::Reimbursement, type: :model do
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
 
     let(:reimbursement) { create(:reimbursement, customer_return: customer_return, order: order, return_items: [return_item]) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
-    subject { reimbursement.perform! }
+    subject { reimbursement.perform!(created_by: created_by_user) }
 
     before do
       order.shipments.each do |shipment|
@@ -230,13 +253,14 @@ RSpec.describe Spree::Reimbursement, type: :model do
   end
 
   describe "#return_all" do
-    subject { reimbursement.return_all }
+    subject { reimbursement.return_all(created_by: created_by_user) }
 
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
     let(:order)                  { create(:shipped_order, line_items_count: 1) }
     let(:inventory_unit)         { order.inventory_units.first }
     let(:return_item)            { build(:return_item, inventory_unit: inventory_unit) }
     let(:reimbursement)          { build(:reimbursement, order: order, return_items: [return_item]) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
     it "accepts all the return items" do
       expect { subject }.to change { return_item.acceptance_status }.to "accepted"