solidus_core 1.1.4 → 1.2.0.beta1

data/spec/models/spree/option_type_spec.rb

@@ -8,7 +8,7 @@ describe Spree::OptionType, :type => :model do
       product = product_option_type.product
       product.update_column(:updated_at, 1.day.ago)
       option_type.touch
-      expect(product.reload.updated_at).to be_within(3.seconds).of(Time.now)
+      expect(product.reload.updated_at).to be_within(3.seconds).of(Time.current)
     end
   end
-end
+end

data/spec/models/spree/option_value_spec.rb

@@ -12,7 +12,7 @@ describe Spree::OptionValue, :type => :model do
     it "should touch a variant" do
       Timecop.freeze do
         option_value.touch
-        expect(variant.reload.updated_at).to be_within(1.second).of(Time.now)
+        expect(variant.reload.updated_at).to be_within(1.second).of(Time.current)
       end
     end
 
@@ -28,7 +28,7 @@ describe Spree::OptionValue, :type => :model do
         Timecop.freeze do
           option_value.name += "--1"
           option_value.save!
-          expect(variant.reload.updated_at).to be_within(1.second).of(Time.now)
+          expect(variant.reload.updated_at).to be_within(1.second).of(Time.current)
         end
       end
     end

data/spec/models/spree/order/callbacks_spec.rb

@@ -8,7 +8,7 @@ describe Spree::Order, :type => :model do
 
   context "validations" do
     context "email validation" do
-      # Regression test for #1238
+      # Regression test for https://github.com/spree/spree/issues/1238
       it "o'brien@gmail.com is a valid email address" do
         order.state = 'address'
         order.email = "o'brien@gmail.com"

data/spec/models/spree/order/checkout_spec.rb

@@ -118,7 +118,7 @@ describe Spree::Order, :type => :model do
 
         it "doesn't raise an error if the default address is invalid" do
           order.user = mock_model(Spree::LegacyUser, ship_address: Spree::Address.new, bill_address: Spree::Address.new)
-          expect { order.next! }.to_not raise_error
+          order.next!
         end
 
         context "with default addresses" do
@@ -417,7 +417,7 @@ describe Spree::Order, :type => :model do
         end
       end
 
-      # Regression test for #2028
+      # Regression test for https://github.com/spree/spree/issues/2028
       context "when payment is not required" do
         before do
           allow(order).to receive_messages :payment_required? => false
@@ -675,7 +675,7 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  # Regression test for #3665
+  # Regression test for https://github.com/spree/spree/issues/3665
   context "with only a complete step" do
     let!(:line_item){ create :line_item, order: order }
 
@@ -782,12 +782,18 @@ describe Spree::Order, :type => :model do
   end
 
   describe 'update_from_params' do
+    let(:order) { create(:order) }
     let(:permitted_params) { {} }
     let(:params) { {} }
 
+    around do |example|
+      ActiveSupport::Deprecation.silence { example.run }
+    end
+
     it 'calls update_atributes without order params' do
-      expect(order).to receive(:update_attributes).with({})
-      order.update_from_params( params, permitted_params)
+      expect {
+        order.update_from_params( params, permitted_params)
+      }.not_to change{order.attributes}
     end
 
     it 'runs the callbacks' do
@@ -837,10 +843,8 @@ describe Spree::Order, :type => :model do
       it "sets request_env on payment" do
         request_env = { "USER_AGENT" => "Firefox" }
 
-        expected_hash = { "payments_attributes" => [hash_including("request_env" => request_env)] }
-        expect(order).to receive(:update_attributes).with expected_hash
-
         order.update_from_params(params, permitted_params, request_env)
+        expect(order.payments[0].request_env).to eq request_env
       end
 
       it "dont let users mess with others users cards" do
@@ -857,7 +861,7 @@ describe Spree::Order, :type => :model do
       let(:params) { ActionController::Parameters.new(order: {  bad_param: 'okay' } ) }
 
       it 'does not let through unpermitted attributes' do
-        expect(order).to receive(:update_attributes).with({})
+        expect(order).to receive(:assign_attributes).with({})
         order.update_from_params(params, permitted_params)
       end
 
@@ -865,7 +869,7 @@ describe Spree::Order, :type => :model do
         let(:params) { ActionController::Parameters.new(order: {  good_param: 'okay' } ) }
 
         it 'accepts permitted attributes' do
-          expect(order).to receive(:update_attributes).with({"good_param" => 'okay'})
+          expect(order).to receive(:assign_attributes).with({"good_param" => 'okay'})
           order.update_from_params(params, permitted_params)
         end
       end
@@ -875,7 +879,8 @@ describe Spree::Order, :type => :model do
           expect(order).to receive(:update_params_payment_source).and_return false
         end
         it 'does not let through unpermitted attributes' do
-          expect(order).not_to receive(:update_attributes).with({})
+          expect(order).not_to receive(:assign_attributes)
+          expect(order).not_to receive(:save)
           order.update_from_params(params, permitted_params)
         end
       end

data/spec/models/spree/order/payment_spec.rb

@@ -68,30 +68,32 @@ module Spree
     end
 
     context "ensure source attributes stick around" do
-      # For the reason of this test, please see spree/spree_gateway#132
-      it "does not have inverse_of defined" do
-        expect(Spree::Order.reflections['payments'].options[:inverse_of]).to be_nil
-      end
-
-      it "keeps source attributes after updating" do
-        persisted_order = Spree::Order.create
-        credit_card_payment_method = create(:credit_card_payment_method)
-        attributes = {
-          :payments_attributes => [
-            {
-              :payment_method_id => credit_card_payment_method.id,
-              :source_attributes => {
-                :name => "Ryan Bigg",
-                :number => "41111111111111111111",
-                :expiry => "01 / 15",
-                :verification_value => "123"
-              }
-            }
-          ]
+      let(:order){ Spree::Order.create }
+      let(:payment_method){ create(:credit_card_payment_method) }
+      let(:payment_attributes) do
+        {
+          :payment_method_id => payment_method.id,
+          :source_attributes => {
+            :name => "Ryan Bigg",
+            :number => "41111111111111111111",
+            :expiry => "01 / 15",
+            :verification_value => "123"
+          }
         }
+      end
 
-        persisted_order.update_attributes(attributes)
-        expect(persisted_order.unprocessed_payments.last.source.number).to be_present
+      # For the reason of this test, please see spree/spree_gateway#132
+      it "keeps source attributes on assignment" do
+        ActiveSupport::Deprecation.silence do
+          order.update_attributes(payments_attributes: [payment_attributes])
+        end
+        expect(order.unprocessed_payments.last.source.number).to be_present
+      end
+
+      # For the reason of this test, please see spree/spree_gateway#132
+      it "keeps source attributes through OrderUpdateAttributes" do
+        OrderUpdateAttributes.new(order, payments_attributes: [payment_attributes]).apply
+        expect(order.unprocessed_payments.last.source.number).to be_present
       end
     end
 

data/spec/models/spree/order/state_machine_spec.rb

@@ -198,7 +198,7 @@ describe Spree::Order, :type => :model do
   end
 
 
-  # Another regression test for #729
+  # Another regression test for https://github.com/spree/spree/issues/729
   context "#resume" do
     before do
       allow(order).to receive_messages email: "user@spreecommerce.com"

data/spec/models/spree/order/validations_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Spree
   describe Spree::Order, :type => :model do
     context "validations" do
-      # Regression test for #2214
+      # Regression test for https://github.com/spree/spree/issues/2214
       it "does not return two error messages when email is blank" do
         order = Spree::Order.new
         allow(order).to receive_messages(:require_email => true)

data/spec/models/spree/order_cancellations_spec.rb

@@ -1,6 +1,69 @@
 require 'spec_helper'
 
 describe Spree::OrderCancellations do
+  describe "#cancel_unit" do
+    subject { Spree::OrderCancellations.new(order).cancel_unit(inventory_unit) }
+    let(:order) { create(:shipped_order, line_items_count: 1) }
+    let(:inventory_unit) { order.inventory_units.first }
+
+    it "creates a UnitCancel record" do
+      expect { subject }.to change { Spree::UnitCancel.count }.by(1)
+      expect(subject.inventory_unit).to eq inventory_unit
+    end
+
+    it "cancels the inventory unit" do
+      expect { subject }.to change { inventory_unit.state }.to "canceled"
+    end
+
+    context "when a reason is specified" do
+      subject { order.cancellations.cancel_unit(inventory_unit, reason: "some reason") }
+
+      it "sets the reason on the UnitCancel" do
+        expect(subject.reason).to eq("some reason")
+      end
+    end
+
+    context "when a reason is not specified" do
+      it "sets a default reason on the UnitCancel" do
+        expect(subject.reason).to eq Spree::UnitCancel::DEFAULT_REASON
+      end
+    end
+
+    context "when a whodunnit is specified" do
+      subject { order.cancellations.cancel_unit(inventory_unit, whodunnit: "some automated system") }
+
+      it "sets the user on the UnitCancel" do
+        expect(subject.created_by).to eq("some automated system")
+      end
+    end
+
+    context "when a whodunnit is not specified" do
+      it "does not set created_by on the UnitCancel" do
+        expect(subject.created_by).to be_nil
+      end
+    end
+  end
+
+  describe "#reimburse_units" do
+    subject { Spree::OrderCancellations.new(order).reimburse_units(inventory_units) }
+    let(:order) { create(:shipped_order, line_items_count: 2) }
+    let(:inventory_units) { order.inventory_units }
+    let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    it "creates and performs a reimbursement" do
+      expect { subject }.to change { Spree::Reimbursement.count }.by(1)
+      expect(subject.refunds.size).to eq 1
+    end
+
+    it "creates return items for the inventory units and accepts them" do
+      expect { subject }.to change { Spree::ReturnItem.count }.by(inventory_units.count)
+
+      return_items = subject.return_items
+      expect(return_items.map(&:acceptance_status)).to all eq "accepted"
+      expect(return_items.map(&:inventory_unit)).to match_array(inventory_units)
+    end
+  end
+
   describe "#short_ship" do
     subject { Spree::OrderCancellations.new(order).short_ship([inventory_unit]) }
 

data/spec/models/spree/order_contents_spec.rb

@@ -245,7 +245,7 @@ describe Spree::OrderContents, :type => :model do
   end
 
   context "completed order" do
-    let(:order) { Spree::Order.create! state: 'complete', completed_at: Time.now }
+    let(:order) { Spree::Order.create! state: 'complete', completed_at: Time.current }
 
     before { order.shipments.create! stock_location_id: variant.stock_location_ids.first }
 

data/spec/models/spree/order_merger_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+# Regression tests for https://github.com/spree/spree/issues/2179
+module Spree
+  describe OrderMerger, type: :model do
+    let(:variant) { create(:variant) }
+    let(:order_1) { Spree::Order.create }
+    let(:order_2) { Spree::Order.create }
+    let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }
+    let(:subject) { Spree::OrderMerger.new(order_1) }
+
+    it "destroys the other order" do
+      subject.merge!(order_2)
+      expect { order_2.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it "persist the merge" do
+      expect(subject).to receive(:persist_merge)
+      subject.merge!(order_2)
+    end
+
+    context "user is provided" do
+      it "assigns user to new order" do
+        subject.merge!(order_2, user)
+        expect(order_1.user).to eq user
+      end
+    end
+
+    context "merging together two orders with line items for the same variant" do
+      before do
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant, 1)
+      end
+
+      specify do
+        subject.merge!(order_2, user)
+        expect(order_1.line_items.count).to eq(1)
+
+        line_item = order_1.line_items.first
+        expect(line_item.quantity).to eq(2)
+        expect(line_item.variant_id).to eq(variant.id)
+      end
+    end
+
+    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
+        # reset to avoid test pollution
+        Spree::Order.line_item_comparison_hooks = Set.new
+      end
+
+      context "2 equal line items" do
+        before do
+          @line_item_1 = order_1.contents.add(variant, 1, foos: {})
+          @line_item_2 = order_2.contents.add(variant, 1, foos: {})
+        end
+
+        specify do
+          expect(order_1).to receive(:foos_match).with(@line_item_1, kind_of(Hash)).and_return(true)
+          subject.merge!(order_2)
+          expect(order_1.line_items.count).to eq(1)
+
+          line_item = order_1.line_items.first
+          expect(line_item.quantity).to eq(2)
+          expect(line_item.variant_id).to eq(variant.id)
+        end
+      end
+
+      context "2 different line items" do
+        before do
+          allow(order_1).to receive(:foos_match).and_return(false)
+
+          order_1.contents.add(variant, 1, foos: {})
+          order_2.contents.add(variant, 1, foos: { bar: :zoo })
+        end
+
+        specify do
+          subject.merge!(order_2)
+          expect(order_1.line_items.count).to eq(2)
+
+          line_item = order_1.line_items.first
+          expect(line_item.quantity).to eq(1)
+          expect(line_item.variant_id).to eq(variant.id)
+
+          line_item = order_1.line_items.last
+          expect(line_item.quantity).to eq(1)
+          expect(line_item.variant_id).to eq(variant.id)
+        end
+      end
+    end
+
+    context "merging together two orders with different line items" do
+      let(:variant_2) { create(:variant) }
+
+      before do
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant_2, 1)
+      end
+
+      specify do
+        subject.merge!(order_2)
+        line_items = order_1.line_items.reload
+        expect(line_items.count).to eq(2)
+
+        expect(order_1.item_count).to eq 2
+        expect(order_1.item_total).to eq line_items.map(&:amount).sum
+
+        # No guarantee on ordering of line items, so we do this:
+        expect(line_items.pluck(:quantity)).to match_array([1, 1])
+        expect(line_items.pluck(:variant_id)).to match_array([variant.id, variant_2.id])
+      end
+    end
+
+    context "merging together orders with invalid line items" do
+      let(:variant_2) { create(:variant) }
+
+      before do
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant_2, 1)
+      end
+
+      it "should create errors with invalid line items" do
+        variant_2.really_destroy!
+        subject.merge!(order_2)
+        expect(order_1.errors.full_messages).not_to be_empty
+      end
+    end
+  end
+end

data/spec/models/spree/order_spec.rb

@@ -197,111 +197,37 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  # Regression tests for #2179
-  context "#merge!" do
-    let(:variant) { create(:variant) }
-    let(:order_1) { Spree::Order.create }
-    let(:order_2) { Spree::Order.create }
+  describe '#merge!' do
+    let(:order1) { create(:order_with_line_items) }
+    let(:order2) { create(:order_with_line_items) }
 
-    it "destroys the other order" do
-      order_1.merge!(order_2)
-      expect { order_2.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    it 'merges the orders' do
+      order1.merge!(order2)
+      expect(order1.line_items.count).to eq(2)
+      expect(order2.destroyed?).to be_truthy
     end
 
-    context "user is provided" do
-      it "assigns user to new order" do
-        order_1.merge!(order_2, user)
-        expect(order_1.user).to eq user
-      end
-    end
-
-    context "merging together two orders with line items for the same variant" do
-      before do
-        order_1.contents.add(variant, 1)
-        order_2.contents.add(variant, 1)
-      end
-
-      specify do
-        order_1.merge!(order_2)
-        expect(order_1.line_items.count).to eq(1)
-
-        line_item = order_1.line_items.first
-        expect(line_item.quantity).to eq(2)
-        expect(line_item.variant_id).to eq(variant.id)
-      end
-
-    end
-
-    context "merging using extension-specific line_item_comparison_hooks" do
+    describe 'order_merger_class customization' 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
-        # reset to avoid test pollution
-        Spree::Order.line_item_comparison_hooks = Set.new
-      end
-
-      context "2 equal line items" do
-        before do
-          @line_item_1 = order_1.contents.add(variant, 1, {foos: {}})
-          @line_item_2 = order_2.contents.add(variant, 1, {foos: {}})
-        end
-
-        specify do
-          expect(order_1).to receive(:foos_match).with(@line_item_1, kind_of(Hash)).and_return(true)
-          order_1.merge!(order_2)
-          expect(order_1.line_items.count).to eq(1)
-
-          line_item = order_1.line_items.first
-          expect(line_item.quantity).to eq(2)
-          expect(line_item.variant_id).to eq(variant.id)
-        end
-      end
-
-      context "2 different line items" do
-        before do
-          allow(order_1).to receive(:foos_match).and_return(false)
-
-          order_1.contents.add(variant, 1, {foos: {}})
-          order_2.contents.add(variant, 1, {foos: {bar: :zoo}})
-        end
-
-        specify do
-          order_1.merge!(order_2)
-          expect(order_1.line_items.count).to eq(2)
-
-          line_item = order_1.line_items.first
-          expect(line_item.quantity).to eq(1)
-          expect(line_item.variant_id).to eq(variant.id)
-
-          line_item = order_1.line_items.last
-          expect(line_item.quantity).to eq(1)
-          expect(line_item.variant_id).to eq(variant.id)
+        class TestOrderMerger
+          def initialize(order)
+            @order = order
+          end
+          def merge!(other_order, user = nil)
+            [@order, other_order, user]
+          end
         end
+        Spree::Config.order_merger_class = TestOrderMerger
       end
-    end
 
-    context "merging together two orders with different line items" do
-      let(:variant_2) { create(:variant) }
-
-      before do
-        order_1.contents.add(variant, 1)
-        order_2.contents.add(variant_2, 1)
+      after do
+        Spree::Config.order_merger_class = Spree::PromotionChooser
       end
 
-      specify do
-        order_1.merge!(order_2)
-        line_items = order_1.line_items.reload
-        expect(line_items.count).to eq(2)
+      let(:user) { build(:user) }
 
-        expect(order_1.item_count).to eq 2
-        expect(order_1.item_total).to eq line_items.map(&:amount).sum
-
-        # No guarantee on ordering of line items, so we do this:
-        expect(line_items.pluck(:quantity)).to match_array([1, 1])
-        expect(line_items.pluck(:variant_id)).to match_array([variant.id, variant_2.id])
+      it 'uses the configured order merger' do
+        expect(order1.merge!(order2, user)).to eq([order1, order2, user])
       end
     end
   end
@@ -399,7 +325,7 @@ describe Spree::Order, :type => :model do
     context 'when the order is completed' do
       before do
         order.state = 'complete'
-        order.completed_at = Time.now
+        order.completed_at = Time.current
         order.update_column(:shipment_total, 5)
         order.shipments.create!
       end
@@ -488,7 +414,7 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  # Regression tests for #4072
+  # Regression tests for https://github.com/spree/spree/issues/4072
   context "#state_changed" do
     let(:order) { FactoryGirl.create(:order) }
 
@@ -510,7 +436,7 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  # Regression test for #4199
+  # Regression test for https://github.com/spree/spree/issues/4199
   context "#available_payment_methods" do
     it "includes frontend payment methods" do
       payment_method = Spree::PaymentMethod.create!({
@@ -765,7 +691,7 @@ describe Spree::Order, :type => :model do
       order.completed_at = nil
       expect(order.completed?).to be false
 
-      order.completed_at = Time.now
+      order.completed_at = Time.current
       expect(order.completed?).to be true
     end
   end
@@ -804,14 +730,14 @@ describe Spree::Order, :type => :model do
     it "should be false for completed order in the canceled state" do
       order.state = 'canceled'
       order.shipment_state = 'ready'
-      order.completed_at = Time.now
+      order.completed_at = Time.current
       expect(order.can_cancel?).to be false
     end
 
     it "should be true for completed order with no shipment" do
       order.state = 'complete'
       order.shipment_state = nil
-      order.completed_at = Time.now
+      order.completed_at = Time.current
       expect(order.can_cancel?).to be true
     end
   end
@@ -824,12 +750,12 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  # Regression test for #4923
+  # Regression test for https://github.com/spree/spree/issues/4923
   context "locking" do
     let(:order) { Spree::Order.create } # need a persisted in order to test locking
 
     it 'can lock' do
-      expect { order.with_lock {} }.to_not raise_error
+      order.with_lock {}
     end
   end
 
@@ -846,11 +772,11 @@ describe Spree::Order, :type => :model do
 
   context "#refund_total" do
     let(:order) { create(:order_with_line_items) }
-    let!(:payment) { create(:payment_with_refund, order: order) }
-    let!(:payment2) { create(:payment_with_refund, order: order) }
+    let!(:payment) { create(:payment_with_refund, order: order, amount: 5, refund_amount: 3) }
+    let!(:payment2) { create(:payment_with_refund, order: order, amount: 5, refund_amount: 2.5) }
 
     it "sums the reimbursment refunds on the order" do
-      expect(order.refund_total).to eq(10.0)
+      expect(order.refund_total).to eq(5.5)
     end
   end
 
@@ -894,7 +820,7 @@ describe Spree::Order, :type => :model do
 
     context 'a reimbursement related refund exists' do
       let(:order) { refund.payment.order }
-      let(:refund) { create(:refund, reimbursement_id: 123, amount: 5)}
+      let(:refund) { create(:refund, reimbursement_id: 123, amount: 5, payment_amount: 14)}
 
       it { is_expected.to eq false }
     end
@@ -1027,6 +953,12 @@ describe Spree::Order, :type => :model do
     let(:shipment) { Spree::Shipment.new(cost: 10) }
     let(:payment) { Spree::Payment.new(amount: 10) }
 
+    around do |example|
+      ActiveSupport::Deprecation.silence do
+        example.run
+      end
+    end
+
     before do
       allow(order).to receive(:line_items) { [line_item] }
       allow(order).to receive(:shipments) { [shipment] }
@@ -1479,56 +1411,4 @@ describe Spree::Order, :type => :model do
       end
     end
   end
-
-  describe "#validate_payments_attributes" do
-    let(:attributes) { [ActionController::Parameters.new(payment_method_id: payment_method.id)] }
-    subject do
-      order.validate_payments_attributes(attributes)
-    end
-
-    context "with empty array" do
-      let(:attributes) { [] }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with no payment method specified" do
-      let(:attributes) { [ActionController::Parameters.new({})] }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with valid payment method" do
-      let(:payment_method) { create(:check_payment_method) }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with inactive payment method" do
-      let(:payment_method) { create(:check_payment_method, active: false) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with unavailable payment method" do
-      let(:payment_method) { create(:check_payment_method, display_on: "back_end") }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with soft-deleted payment method" do
-      let(:payment_method) { create(:check_payment_method, deleted_at: Time.current) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
 end