solidus_core 2.1.0.beta1 → 2.1.0.rc1

data/spec/models/spree/calculator/tiered_percent_spec.rb

@@ -8,23 +8,67 @@ describe Spree::Calculator::TieredPercent, type: :model do
 
   describe "#valid?" do
     subject { calculator.valid? }
+
     context "when base percent is less than zero" do
       before { calculator.preferred_base_percent = -1 }
       it { is_expected.to be false }
     end
+
     context "when base percent is greater than 100" do
       before { calculator.preferred_base_percent = 110 }
       it { is_expected.to be false }
     end
+
     context "when tiers is a hash" do
-      context "and one of the keys is not a positive number" do
+      context "and the key is not a positive number" do
         before { calculator.preferred_tiers = { "nope" => 20 } }
         it { is_expected.to be false }
       end
+
       context "and one of the values is not a percent" do
         before { calculator.preferred_tiers = { 10 => 110 } }
         it { is_expected.to be false }
       end
+
+      context "and the key is an integer" do
+        before { calculator.preferred_tiers = { 20 => 20 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20') => BigDecimal.new('20') })
+        end
+      end
+
+      context "and the key is a float" do
+        before { calculator.preferred_tiers = { 20.5 => 20.5 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20.5') => BigDecimal.new('20.5') })
+        end
+      end
+
+      context "and the key is a string number" do
+        before { calculator.preferred_tiers = { "20" => 20 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20') => BigDecimal.new('20') })
+        end
+      end
+
+      context "and the key is a numeric string with spaces" do
+        before { calculator.preferred_tiers = { "  20 " => 20 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20') => BigDecimal.new('20') })
+        end
+      end
+
+      context "and the key is a string number with decimals" do
+        before { calculator.preferred_tiers = { "20.5" => "20.5" } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20.5') => BigDecimal.new('20.5') })
+        end
+      end
     end
   end
 

data/spec/models/spree/gateway/bogus_spec.rb

@@ -4,12 +4,5 @@ module Spree
   describe Gateway::Bogus, type: :model do
     let(:bogus) { create(:credit_card_payment_method) }
     let!(:cc) { create(:credit_card, payment_method: bogus, gateway_customer_profile_id: "BGS-RERTERT") }
-
-    it "disable recurring contract by destroying payment source" do
-      Spree::Deprecation.silence do
-        bogus.disable_customer_profile(cc)
-      end
-      expect(cc.gateway_customer_profile_id).to be_nil
-    end
   end
 end

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

@@ -775,123 +775,4 @@ describe Spree::Order, type: :model do
       expect(order.checkout_steps).to eq(%w(delivery confirm complete))
     end
   end
-
-  describe 'update_from_params' do
-    let(:order) { create(:order) }
-    let(:permitted_params) { {} }
-    let(:params) { {} }
-
-    around do |example|
-      Spree::Deprecation.silence { example.run }
-    end
-
-    it 'calls update_atributes without order params' do
-      expect {
-        order.update_from_params( params, permitted_params)
-      }.not_to change{ order.attributes }
-    end
-
-    it 'runs the callbacks' do
-      expect(order).to receive(:run_callbacks).with(:updating_from_params)
-      order.update_from_params( params, permitted_params)
-    end
-
-    context "passing a credit card" do
-      let(:permitted_params) do
-        Spree::PermittedAttributes.checkout_attributes +
-          [payments_attributes: Spree::PermittedAttributes.payment_attributes]
-      end
-
-      let(:credit_card) { create(:credit_card, user_id: order.user_id) }
-
-      let(:params) do
-        ActionController::Parameters.new(
-          order: {
-            payments_attributes: [
-              {
-                payment_method_id: 1,
-                source_attributes: attributes_for(:credit_card)
-              }
-            ],
-            existing_card: credit_card.id
-          },
-          cvc_confirm: "737"
-        )
-      end
-
-      before { order.user_id = 3 }
-
-      it "sets confirmation value when its available via :cvc_confirm" do
-        allow(Spree::CreditCard).to receive_messages find: credit_card
-        expect(credit_card).to receive(:verification_value=)
-        order.update_from_params(params, permitted_params)
-      end
-
-      it "sets existing card as source for new payment" do
-        expect {
-          order.update_from_params(params, permitted_params)
-        }.to change { Spree::Payment.count }.by(1)
-
-        expect(Spree::Payment.last.source).to eq credit_card
-      end
-
-      it "sets request_env on payment" do
-        request_env = { "USER_AGENT" => "Firefox" }
-
-        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
-        credit_card.update_column :user_id, 5
-
-        expect {
-          order.update_from_params(params, permitted_params)
-        }.to raise_error Spree::Core::GatewayError
-      end
-    end
-
-    context 'has params' do
-      let(:permitted_params) { [:good_param] }
-      let(:params) { ActionController::Parameters.new(order: { bad_param: 'okay' } ) }
-
-      it 'does not let through unpermitted attributes' do
-        expect(order).to receive(:assign_attributes).with(ActionController::Parameters.new.permit!)
-        order.update_from_params(params, permitted_params)
-      end
-
-      context 'has allowed params' do
-        let(:params) { ActionController::Parameters.new(order: { good_param: 'okay' } ) }
-
-        it 'accepts permitted attributes' do
-          expect(order).to receive(:assign_attributes).with(ActionController::Parameters.new("good_param" => 'okay').permit!)
-          order.update_from_params(params, permitted_params)
-        end
-      end
-
-      context 'callback returns false' do
-        before 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(:assign_attributes)
-          expect(order).not_to receive(:save)
-          ActiveSupport::Deprecation.silence do
-            order.update_from_params(params, permitted_params)
-          end
-        end
-      end
-
-      context 'callback throws abort' do
-        before do
-          expect(order).to receive(:update_params_payment_source).and_throw :abort
-        end
-        it 'does not let through unpermitted attributes' do
-          expect(order).not_to receive(:assign_attributes)
-          expect(order).not_to receive(:save)
-          order.update_from_params(params, permitted_params)
-        end
-      end
-    end
-  end
 end

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

@@ -77,11 +77,8 @@ module Spree
         }
       end
 
-      # For the reason of this test, please see spree/spree_gateway#132
       it "keeps source attributes on assignment" do
-        Spree::Deprecation.silence do
-          order.update_attributes(payments_attributes: [payment_attributes])
-        end
+        OrderUpdateAttributes.new(order, payments_attributes: [payment_attributes]).apply
         expect(order.unprocessed_payments.last.source.number).to be_present
       end
 
@@ -218,15 +215,27 @@ module Spree
       end
     end
 
-    context "payment required?" do
+    context "payment_required?" do
+      before { order.total = total }
+
       context "total is zero" do
-        before { allow(order).to receive_messages(total: 0) }
-        it { expect(order.payment_required?).to be false }
+        let(:total) { 0 }
+        it { expect(order).not_to be_payment_required }
+      end
+
+      context "total is once cent" do
+        let(:total) { 1 }
+        it { expect(order).to be_payment_required }
+      end
+
+      context "total is once dollar" do
+        let(:total) { 1 }
+        it { expect(order).to be_payment_required }
       end
 
-      context "total > zero" do
-        before { allow(order).to receive_messages(total: 1) }
-        it { expect(order.payment_required?).to be true }
+      context "total is huge" do
+        let(:total) { 2**32 }
+        it { expect(order).to be_payment_required }
       end
     end
   end

data/spec/models/spree/order_spec.rb

@@ -1049,51 +1049,6 @@ describe Spree::Order, type: :model do
     end
   end
 
-  describe "#fully_discounted?" do
-    let(:line_item) { Spree::LineItem.new(price: 10, quantity: 1) }
-    let(:shipment) { Spree::Shipment.new(cost: 10) }
-    let(:payment) { Spree::Payment.new(amount: 10) }
-
-    around do |example|
-      Spree::Deprecation.silence do
-        example.run
-      end
-    end
-
-    before do
-      allow(order).to receive(:line_items) { [line_item] }
-      allow(order).to receive(:shipments) { [shipment] }
-      allow(order).to receive(:payments) { [payment] }
-    end
-
-    context "the order had no inventory-related cost" do
-      before do
-        # discount the cost of the line items
-        allow(order).to receive(:adjustment_total) { -5 }
-        allow(line_item).to receive(:adjustment_total) { -5 }
-
-        # but leave some shipment payment amount
-        allow(shipment).to receive(:adjustment_total) { 0 }
-      end
-
-      it { expect(order.fully_discounted?).to eq true }
-    end
-
-    context "the order had inventory-related cost" do
-      before do
-        # partially discount the cost of the line item
-        allow(order).to receive(:adjustment_total) { 0 }
-        allow(line_item).to receive(:adjustment_total) { -5 }
-
-        # and partially discount the cost of the shipment so the total
-        # discount matches the item total for test completeness
-        allow(shipment).to receive(:adjustment_total) { -5 }
-      end
-
-      it { expect(order.fully_discounted?).to eq false }
-    end
-  end
-
   context "store credit" do
     shared_examples "check total store credit from payments" do
       context "with valid payments" do

data/spec/models/spree/payment_spec.rb

@@ -686,25 +686,22 @@ describe Spree::Payment, type: :model do
 
       context "with multiple payment attempts" do
         let(:attributes) { attributes_for(:credit_card) }
-        around do |example|
-          Spree::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 }
 
-          order.payments.create!(
+          Spree::PaymentCreate.new(order, {
             source_attributes: attributes,
             payment_method: gateway,
             amount: 100
-          )
+          }).build.save!
           expect(gateway).to receive(:create_profile).exactly :once
           expect(order.payments.count).to eq(1)
-          order.payments.create!(
+          Spree::PaymentCreate.new(order, {
             source_attributes: attributes,
             payment_method: gateway,
             amount: 100
-          )
+          }).build.save!
         end
       end
 
@@ -762,14 +759,8 @@ describe Spree::Payment, type: :model do
     end
   end
 
+  # This used to describe #apply_source_attributes, whose behaviour is now part of PaymentCreate
   describe "#apply_source_attributes" do
-    # This method is deprecated
-    around do |example|
-      Spree::Deprecation.silence do
-        example.run
-      end
-    end
-
     context 'with a new source' do
       let(:params) do
         {
@@ -785,14 +776,15 @@ describe Spree::Payment, type: :model do
       end
 
       it "should build the payment's source" do
-        payment = Spree::Payment.new(params)
+        payment = Spree::PaymentCreate.new(order, params).build
         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
+        payment = Spree::PaymentCreate.new(order, params).build
+        source = payment.source
 
         expect(source.user_id).to eq order.user_id
         expect(source.payment_method_id).to eq gateway.id
@@ -802,18 +794,12 @@ describe Spree::Payment, type: :model do
         params = { amount: 100, payment_method: gateway,
           source_attributes: { expiry: "1 / 12" } }
 
-        payment = Spree::Payment.new(params)
+        payment = Spree::PaymentCreate.new(order, params).build
         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
 
     context 'with an existing credit card' do
@@ -830,58 +816,65 @@ describe Spree::Payment, type: :model do
         }
       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)
+      describe "building a payment" do
+        subject do
+          Spree::PaymentCreate.new(order, params).build.save!
+        end
 
-        expect(order.payments.last.source).to eq(credit_card)
-      end
+        it 'sets the existing card as the source for the new payment' do
+          expect {
+            subject
+          }.to change { Spree::Payment.count }.by(1)
 
-      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
+          expect(order.payments.last.source).to eq(credit_card)
+        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 payment payment_method to that of the credit card' do
+          subject
+          expect(order.payments.last.payment_method_id).to eq(credit_card.payment_method_id)
+        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
+        it 'sets the verification_value on the credit card' do
+          subject
+          expect(order.payments.last.source.verification_value).to eq('321')
+        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)
+        it 'sets the request_env on the payment' do
+          payment = Spree::PaymentCreate.new(order, params.merge(request_env: { 'USER_AGENT' => 'Firefox' })).build
+          payment.save!
+          expect(payment.request_env).to eq({ 'USER_AGENT' => 'Firefox' })
         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)
+        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 { subject }.to raise_error(ActiveRecord::RecordNotFound)
+          end
         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)
+        context 'the credit card has no user' do
+          before { credit_card.update!(user_id: nil) }
+          it 'errors' do
+            expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
+          end
         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)
+        context 'the order has no user' do
+          before { order.update_attributes!(user_id: nil) }
+          it 'errors' do
+            expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
+          end
         end
-        it 'errors' do
-          expect { order.payments.create!(params) }.to raise_error(ActiveRecord::RecordNotFound)
+
+        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 { subject }.to raise_error(ActiveRecord::RecordNotFound)
+          end
         end
       end
     end