solidus_core 1.1.4 → 1.2.0.beta1

data/spec/models/spree/order_update_attributes_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module Spree
+  RSpec.describe OrderUpdateAttributes do
+    let(:order) { create(:order) }
+    let(:request_env) { nil }
+    let(:update) { described_class.new(order, attributes, request_env: request_env) }
+
+    context 'empty attributes' do
+      let(:attributes){ {} }
+      it 'succeeds' do
+        expect(update.apply).to be_truthy
+      end
+    end
+
+    context 'with coupon code' do
+      let(:attributes){ {coupon_code: 'abc123'} }
+      it "sets coupon code" do
+        expect(update.apply).to be_truthy
+        expect(order.coupon_code).to eq('abc123')
+      end
+    end
+
+    context 'with payment attributes' do
+      let(:attributes) do
+        {
+          payments_attributes: [
+            {source_attributes: attributes_for(:credit_card)}
+          ]
+        }
+      end
+
+      context 'with params and a request_env' do
+        let(:request_env){ {'USER_AGENT' => 'Firefox'} }
+        it 'sets the request_env on the payment' do
+          expect(update.apply).to be_truthy
+          expect(order.payments.length).to eq 1
+          expect(order.payments[0].request_env).to eq({'USER_AGENT' => 'Firefox'})
+        end
+      end
+    end
+
+    context 'when changing shipping method' do
+      let!(:order) { create(:order_with_line_items, shipping_method: shipping_method1) }
+      let(:shipment){ order.shipments.first }
+      let!(:zone) { create(:zone) }
+      let!(:shipping_method1){ create(:shipping_method, cost: 10, zones: [zone]) }
+      let!(:shipping_method2){ create(:shipping_method, cost: 20, zones: [zone]) }
+
+      let(:attributes) do
+        {
+          shipments_attributes: {
+            0 => {selected_shipping_rate_id: shipping_method2, id: shipment.id }
+          }
+        }
+      end
+
+      it "updates shipment costs" do
+        zone.zone_members.create!(zoneable: order.ship_address.country)
+        order.create_proposed_shipments
+        order.set_shipments_cost
+
+        shipping_rate2 = shipment.shipping_rates.find_by(shipping_method_id: shipping_method2.id)
+
+        expect(order.shipment_total).to eq(10)
+
+        # We need an order which doesn't have shipping_rates loaded
+        order.reload
+
+        described_class.new(
+          order,
+          shipments_attributes: {
+            0 => {selected_shipping_rate_id: shipping_rate2.id, id: shipment.id }
+          }
+        ).apply
+
+        expect(order.shipment_total).to eq(20)
+        expect(order.shipments.first.cost).to eq(20)
+      end
+    end
+  end
+end

data/spec/models/spree/order_updater_spec.rb

@@ -12,10 +12,12 @@ module Spree
         end
       end
 
-      it "updates payment totals" do
-        create(:payment_with_refund, order: order)
-        Spree::OrderUpdater.new(order).update_payment_total
-        expect(order.payment_total).to eq(40.75)
+      context 'with refund' do
+        it "updates payment totals" do
+          create(:payment_with_refund, order: order, amount: 33.25, refund_amount: 3)
+          Spree::OrderUpdater.new(order).update_payment_total
+          expect(order.payment_total).to eq(30.25)
+        end
       end
 
       it "update item total" do

data/spec/models/spree/payment_create_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Spree
+  RSpec.describe PaymentCreate do
+    let(:user) { nil }
+    let(:order) { create :order, user: user }
+    let(:request_env) { {} }
+    let(:payment_create) { described_class.new(order, attributes, request_env: request_env) }
+    let(:payment_method) { create(:payment_method) }
+    let(:new_payment) { payment_create.build }
+
+    context 'empty attributes' do
+      let(:attributes){ {} }
+      it "builds a new empty payment" do
+        expect(new_payment).to be_a Spree::Payment
+        expect(new_payment.order).to eq order
+        expect(new_payment.source).to be_nil
+      end
+
+      it "builds the payment in order.payments" do
+        expect(order.payments).to eq [new_payment]
+      end
+    end
+
+    context 'with a new source' do
+      let(:attributes) do
+        {
+          :amount => 100,
+          :payment_method => payment_method,
+          :source_attributes => {
+            :expiry =>"01 / 99",
+            :number => '1234567890123',
+            :verification_value => '123',
+            :name => 'Foo Bar'
+          }
+        }
+      end
+
+      it "should build the payment's source" do
+        expect(new_payment).to be_valid
+        expect(new_payment.source).not_to be_nil
+        expect(new_payment.source.user_id).to eq order.user_id
+        expect(new_payment.source.payment_method_id).to eq payment_method.id
+      end
+
+      context "when payment source not valid" do
+        let(:attributes) do
+          {
+            amount: 100,
+            payment_method: payment_method,
+            source_attributes: {expiry: "1 / 12"}
+          }
+
+        end
+        it "errors when payment source not valid" do
+          expect(new_payment).not_to be_valid
+          expect(new_payment).not_to be_persisted
+          expect(new_payment.source).not_to be_persisted
+          expect(new_payment.source).not_to be_valid
+          expect(new_payment.source.error_on(:number)).to be_present
+          expect(new_payment.source.error_on(:verification_value).size).to be_present
+        end
+      end
+    end
+
+    context 'with an existing credit card' do
+      let(:user) { create(:user) }
+      let!(:credit_card) { create(:credit_card, user: order.user) }
+
+      let(:attributes) do
+        {
+          source_attributes: {
+            existing_card_id: credit_card.id,
+            verification_value: '321',
+          }
+        }
+      end
+
+      it 'sets the existing card as the source for the new payment' do
+        expect(new_payment.source).to eq(credit_card)
+      end
+
+      it 'sets the payment payment_method to that of the credit card' do
+        expect(new_payment.payment_method_id).to eq(credit_card.payment_method_id)
+      end
+
+      it 'sets the verification_value on the credit card' do
+        expect(new_payment.source.verification_value).to eq('321')
+      end
+
+      context 'with request_env' do
+        let(:request_env){ {'USER_AGENT' => 'Firefox'} }
+        it 'sets the request_env on the payment' do
+          expect(new_payment.request_env).to eq({'USER_AGENT' => 'Firefox'})
+        end
+      end
+
+      context 'the credit card belongs to a different user' do
+        let(:other_user) { create(:user) }
+        before { credit_card.update!(user: other_user) }
+        it 'errors' do
+          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context 'the credit card has no user' do
+        before { credit_card.update!(user_id: nil) }
+        it 'errors' do
+          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context 'the order has no user' do
+        before { order.update_attributes!(user_id: nil) }
+        it 'errors' do
+          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context 'the order and the credit card have no user' do
+        before do
+          order.update_attributes!(user_id: nil)
+          credit_card.update!(user_id: nil)
+        end
+        it 'errors' do
+          expect { new_payment }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/payment_spec.rb

@@ -214,7 +214,7 @@ describe Spree::Payment, :type => :model do
         expect(payment.state).to eq('invalid')
       end
 
-      # Regression test for #4598
+      # Regression test for https://github.com/spree/spree/issues/4598
       it "should allow payments with a gateway_customer_profile_id" do
         allow(payment.source).to receive_messages :gateway_customer_profile_id => "customer_1"
         expect(payment.payment_method).to receive(:supports?).with(payment.source).and_return(false)
@@ -222,7 +222,7 @@ describe Spree::Payment, :type => :model do
         payment.process!
       end
 
-      # Another regression test for #4598
+      # Another regression test for https://github.com/spree/spree/issues/4598
       it "should allow payments with a gateway_payment_profile_id" do
         allow(payment.source).to receive_messages :gateway_payment_profile_id => "customer_1"
         expect(payment.payment_method).to receive(:supports?).with(payment.source).and_return(false)
@@ -471,7 +471,7 @@ describe Spree::Payment, :type => :model do
         end
       end
 
-      # Regression test for #2119
+      # Regression test for https://github.com/spree/spree/issues/2119
       context "when payment is completed" do
         before do
           payment.state = 'completed'
@@ -558,7 +558,7 @@ describe Spree::Payment, :type => :model do
         end
       end
 
-      # Regression test for #2119
+      # Regression test for https://github.com/spree/spree/issues/2119
       context "if payment is already voided" do
         before do
           payment.state = 'void'
@@ -601,13 +601,13 @@ describe Spree::Payment, :type => :model do
       end
 
       specify do
-        expect { payment.process! }.not_to raise_error
+        payment.process!
       end
     end
   end
 
   describe "#credit_allowed" do
-    # Regression test for #4403 & #4407
+    # Regression test for https://github.com/spree/spree/issues/4403 and https://github.com/spree/spree/issues/4407
     it "is the difference between offsets total and payment amount" do
       payment.amount = 100
       allow(payment).to receive(:offsets_total).and_return(0)
@@ -661,13 +661,12 @@ describe Spree::Payment, :type => :model do
     end
 
     context "completed orders" do
-      let(:payment_method) { create(:check_payment_method) }
       before { allow(order).to receive_messages completed?: true }
 
       it "updates payment_state and shipments" do
         expect(order.updater).to receive(:update_payment_state)
         expect(order.updater).to receive(:update_shipment_state)
-        Spree::Payment.create!(amount: 100, order: order, payment_method: payment_method)
+        Spree::Payment.create(:amount => 100, :order => order)
       end
     end
 
@@ -693,6 +692,10 @@ describe Spree::Payment, :type => :model do
 
       context "with multiple payment attempts" do
         let(:attributes) { attributes_for(:credit_card) }
+        around do |example|
+          ActiveSupport::Deprecation.silence{ example.run }
+        end
+
         it "should not try to create profiles on old failed payment attempts" do
           allow_any_instance_of(Spree::Payment).to receive(:payment_method) { gateway }
 
@@ -749,49 +752,128 @@ describe Spree::Payment, :type => :model do
     end
   end
 
-  describe "#build_source" do
-    let(:params) do
-      {
-        :amount => 100,
-        :payment_method => gateway,
-        :source_attributes => {
-          :expiry =>"01 / 99",
-          :number => '1234567890123',
-          :verification_value => '123',
-          :name => 'Spree Commerce'
-        }
-      }
+  describe "#apply_source_attributes" do
+    # This method is deprecated
+    around do |example|
+      ActiveSupport::Deprecation.silence do
+        example.run
+      end
     end
 
-    it "should build the payment's source" do
-      payment = Spree::Payment.new(params)
-      expect(payment).to be_valid
-      expect(payment.source).not_to be_nil
-    end
+    context 'with a new source' do
+      let(:params) do
+        {
+          :amount => 100,
+          :payment_method => gateway,
+          :source_attributes => {
+            :expiry =>"01 / 99",
+            :number => '1234567890123',
+            :verification_value => '123',
+            :name => 'Spree Commerce'
+          }
+        }
+      end
+
+      it "should build the payment's source" do
+        payment = Spree::Payment.new(params)
+        expect(payment).to be_valid
+        expect(payment.source).not_to be_nil
+      end
 
-    it "assigns user and gateway to payment source" do
-      order = create(:order)
-      source = order.payments.new(params).source
+      it "assigns user and gateway to payment source" do
+        order = create(:order)
+        source = order.payments.new(params).source
 
-      expect(source.user_id).to eq order.user_id
-      expect(source.payment_method_id).to eq gateway.id
-    end
+        expect(source.user_id).to eq order.user_id
+        expect(source.payment_method_id).to eq gateway.id
+      end
 
-    it "errors when payment source not valid" do
-      params = { :amount => 100, :payment_method => gateway,
-        :source_attributes => {:expiry => "1 / 12" }}
+      it "errors when payment source not valid" do
+        params = { :amount => 100, :payment_method => gateway,
+          :source_attributes => {:expiry => "1 / 12" }}
 
-      payment = Spree::Payment.new(params)
-      expect(payment).not_to be_valid
-      expect(payment.source).not_to be_nil
-      expect(payment.source.error_on(:number).size).to eq(1)
-      expect(payment.source.error_on(:verification_value).size).to eq(1)
+        payment = Spree::Payment.new(params)
+        expect(payment).not_to be_valid
+        expect(payment.source).not_to be_nil
+        expect(payment.source.error_on(:number).size).to eq(1)
+        expect(payment.source.error_on(:verification_value).size).to eq(1)
+      end
+
+      it "does not build a new source when duplicating the model with source_attributes set" do
+        payment = create(:payment)
+        payment.source_attributes = params[:source_attributes]
+        expect { payment.dup }.to_not change { payment.source }
+      end
     end
 
-    it "does not build a new source when duplicating the model with source_attributes set" do
-      payment = create(:payment)
-      payment.source_attributes = params[:source_attributes]
-      expect { payment.dup }.to_not change { payment.source }
+    context 'with an existing credit card' do
+      let(:order) { create(:order, user: user) }
+      let(:user) { create(:user) }
+      let!(:credit_card) { create(:credit_card, user_id: order.user_id) }
+
+      let(:params) do
+        {
+          source_attributes: {
+            existing_card_id: credit_card.id,
+            verification_value: '321',
+          },
+        }
+      end
+
+      it 'sets the existing card as the source for the new payment' do
+        expect {
+          order.payments.create!(params)
+        }.to change { Spree::Payment.count }.by(1)
+
+        expect(order.payments.last.source).to eq(credit_card)
+      end
+
+      it 'sets the payment payment_method to that of the credit card' do
+        order.payments.create!(params)
+        expect(order.payments.last.payment_method_id).to eq(credit_card.payment_method_id)
+      end
+
+      it 'sets the verification_value on the credit card' do
+        payment = order.payments.create!(params)
+        expect(payment.source.verification_value).to eq('321')
+      end
+
+      it 'sets the request_env on the payment' do
+        payment = order.payments.create!(params.merge(request_env: {'USER_AGENT' => 'Firefox'}))
+        expect(payment.request_env).to eq({'USER_AGENT' => 'Firefox'})
+      end
+
+      context 'the credit card belongs to a different user' do
+        let(:other_user) { create(:user) }
+        before { credit_card.update!(user_id: other_user.id) }
+        it 'errors' do
+          expect { order.payments.create!(params) }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context 'the credit card has no user' do
+        before { credit_card.update!(user_id: nil) }
+        it 'errors' do
+          expect { order.payments.create!(params) }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context 'the order has no user' do
+        before { order.update_attributes!(user_id: nil) }
+        it 'errors' do
+          expect { order.payments.create!(params) }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context 'the order and the credit card have no user' do
+        before do
+          order.update_attributes!(user_id: nil)
+          credit_card.update!(user_id: nil)
+        end
+        it 'errors' do
+          expect { order.payments.create!(params) }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
     end
   end
 
@@ -808,7 +890,7 @@ describe Spree::Payment, :type => :model do
     end
   end
 
-  # Regression test for #2216
+  # Regression test for https://github.com/spree/spree/issues/2216
   describe "#gateway_options" do
     before { allow(order).to receive_messages(:last_ip_address => "192.168.1.1") }
 
@@ -826,7 +908,7 @@ describe Spree::Payment, :type => :model do
   end
 
   describe "#set_unique_identifier" do
-    # Regression test for #1998
+    # Regression test for https://github.com/spree/spree/issues/1998
     it "sets a unique identifier on create" do
       payment.run_callbacks(:create)
       expect(payment.number).not_to be_blank
@@ -834,7 +916,7 @@ describe Spree::Payment, :type => :model do
       expect(payment.number).to be_a(String)
     end
 
-    # Regression test for #3733
+    # Regression test for https://github.com/spree/spree/issues/3733
     it "does not regenerate the identifier on re-save" do
       payment.save!
       old_number = payment.number
@@ -1040,8 +1122,8 @@ describe Spree::Payment, :type => :model do
     end
   end
 
-  # Regression test for #4072 (kinda)
-  # The need for this was discovered in the research for #4072
+  # Regression test for https://github.com/spree/spree/issues/4072 (kinda)
+  # The need for this was discovered in the research for https://github.com/spree/spree/issues/4072
   context "state changes" do
     it "are logged to the database" do
       expect(payment.state_changes).to be_empty