solidus_core 1.3.2 → 1.4.0.beta1

data/spec/models/spree/payment_create_spec.rb

@@ -43,6 +43,12 @@ module Spree
         expect(new_payment.source.payment_method_id).to eq payment_method.id
       end
 
+      it "doesn't modify passed-in hash" do
+        original = attributes.dup
+        new_payment
+        expect(original).to eq(attributes)
+      end
+
       context "when payment source not valid" do
         let(:attributes) do
           {
@@ -126,5 +132,60 @@ module Spree
         end
       end
     end
+
+    context "with strong params" do
+      let(:valid_attributes) do
+        {
+          amount: 100,
+          payment_method: payment_method,
+          source_attributes: {
+            expiry: "01 / 99",
+            number: '1234567890123',
+            verification_value: '123',
+            name: 'Foo Bar'
+          }
+        }
+      end
+
+      context "unpermitted" do
+        let(:attributes) { ActionController::Parameters.new(valid_attributes) }
+
+        it "ignores all attributes" do
+          expect(new_payment).to have_attributes(
+            amount: 0,
+            payment_method: nil,
+            source: nil
+          )
+        end
+      end
+
+      context "partially permitted" do
+        let(:attributes) do
+          ActionController::Parameters.new(valid_attributes).permit(:amount)
+        end
+
+        it "only uses permitted attributes" do
+          expect(new_payment).to have_attributes(
+            amount: 100, # permitted
+            payment_method: nil, # unpermitted
+            source: nil # unpermitted
+          )
+        end
+      end
+
+      context "all permitted" do
+        let(:attributes) do
+          ActionController::Parameters.new(valid_attributes).permit!
+        end
+
+        it "creates a payment with all attributes" do
+          expect(new_payment).to have_attributes(
+            amount: 100,
+            payment_method: payment_method,
+            source: kind_of(CreditCard)
+          )
+        end
+      end
+    end
   end
 end

data/spec/models/spree/payment_method/store_credit_spec.rb

@@ -251,10 +251,17 @@ describe Spree::PaymentMethod::StoreCredit do
       Spree::PaymentMethod::StoreCredit.new.cancel(auth_code)
     end
 
-    let(:store_credit) { create(:store_credit, amount_used: captured_amount) }
+    let(:store_credit) { create(:store_credit, amount: original_amount, amount_used: captured_amount) }
     let(:auth_code)    { "1-SC-20141111111111" }
+    let(:original_amount) { 100.0 }
     let(:captured_amount) { 10.0 }
 
+    shared_examples "a spree payment method" do
+      it "returns an ActiveMerchant::Billing::Response" do
+        expect(subject).to be_instance_of(ActiveMerchant::Billing::Response)
+      end
+    end
+
     context "capture event found" do
       let!(:store_credit_event) {
         create(:store_credit_capture_event,
@@ -263,9 +270,12 @@ describe Spree::PaymentMethod::StoreCredit do
                                         store_credit: store_credit)
       }
 
-      it "creates a store credit for the same amount that was captured" do
-        expect_any_instance_of(Spree::StoreCredit).to receive(:credit).with(captured_amount, auth_code, store_credit.currency)
-        subject
+      it_behaves_like "a spree payment method"
+
+      it "refunds the capture amount" do
+        expect { subject }.to change{ store_credit.reload.amount_remaining }.
+                              from(original_amount - captured_amount).
+                              to(original_amount)
       end
     end
 
@@ -278,9 +288,12 @@ describe Spree::PaymentMethod::StoreCredit do
                                           store_credit: store_credit)
         }
 
-        it "creates a store credit for the same amount that was captured" do
-          expect_any_instance_of(Spree::StoreCredit).to receive(:void).with(auth_code)
-          subject
+        it_behaves_like "a spree payment method"
+
+        it "refunds the capture amount" do
+          expect { subject }.to change{ store_credit.reload.amount_remaining }.
+                                from(original_amount - captured_amount).
+                                to(original_amount)
         end
       end
 
@@ -289,9 +302,9 @@ describe Spree::PaymentMethod::StoreCredit do
           Spree::PaymentMethod::StoreCredit.new.cancel('INVALID')
         end
 
-        it "returns false" do
-          expect(subject).to be false
-        end
+        it_behaves_like "a spree payment method"
+
+        it { expect(subject.success?).to be(false) }
       end
     end
   end

data/spec/models/spree/payment_spec.rb

@@ -655,13 +655,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
 
@@ -688,7 +687,7 @@ 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 }
+          Spree::Deprecation.silence{ example.run }
         end
 
         it "should not try to create profiles on old failed payment attempts" do
@@ -749,7 +748,7 @@ describe Spree::Payment, type: :model do
   describe "#apply_source_attributes" do
     # This method is deprecated
     around do |example|
-      ActiveSupport::Deprecation.silence do
+      Spree::Deprecation.silence do
         example.run
       end
     end
@@ -1161,4 +1160,18 @@ describe Spree::Payment, type: :model do
       end
     end
   end
+
+  describe "#payment_method" do
+    context 'with a soft-deleted payment method' do
+      before do
+        gateway.save!
+        payment.save!
+        gateway.destroy
+      end
+
+      it "works with a soft deleted payment method" do
+        expect(payment.reload.payment_method).to eq(gateway)
+      end
+    end
+  end
 end

data/spec/models/spree/product_spec.rb

@@ -47,7 +47,7 @@ describe Spree::Product, type: :model do
         end
 
         it "should touch taxons" do
-          taxon = create(:taxon, products: [product])
+          taxon = create(:taxon, product_ids: [product.id])
           taxon.update_columns(updated_at: 1.day.ago)
           product.taxons.reload
           expect { subject }.to change{ taxon.reload.updated_at }

data/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb

@@ -5,8 +5,9 @@ module Spree
     module Actions
       describe CreateItemAdjustments, type: :model do
         let(:order) { create(:order) }
-        let(:promotion) { create(:promotion) }
-        let(:action) { CreateItemAdjustments.new }
+        let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: adjustment_amount) }
+        let(:adjustment_amount) { 10 }
+        let(:action) { promotion.actions.first! }
         let!(:line_item) { create(:line_item, order: order) }
         let(:payload) { { order: order, promotion: promotion } }
 
@@ -18,9 +19,7 @@ module Spree
         context "#perform" do
           # Regression test for https://github.com/spree/spree/issues/3966
           context "when calculator computes 0" do
-            before do
-              allow(action).to receive_messages compute_amount: 0
-            end
+            let(:adjustment_amount) { 0 }
 
             it "does not create an adjustment when calculator returns 0" do
               action.perform(payload)
@@ -29,20 +28,17 @@ module Spree
           end
 
           context "when calculator returns a non-zero value" do
-            before do
-              promotion.promotion_actions = [action]
-              allow(action).to receive_messages compute_amount: 10
-            end
+            let(:adjustment_amount) { 10 }
 
             it "creates adjustment with item as adjustable" do
               action.perform(payload)
               expect(action.adjustments.count).to eq(1)
-              expect(line_item.reload.adjustments).to eq(action.adjustments)
+              expect(line_item.adjustments).to eq(action.adjustments)
             end
 
             it "creates adjustment with self as source" do
               action.perform(payload)
-              expect(line_item.reload.adjustments.first.source).to eq action
+              expect(line_item.adjustments.first.source).to eq action
             end
 
             it "does not perform twice on the same item" do
@@ -83,8 +79,7 @@ module Spree
             end
 
             context "when a promotion code is used" do
-              let(:promotion_code) { create(:promotion_code) }
-              let(:promotion) { promotion_code.promotion }
+              let!(:promotion_code) { create(:promotion_code, promotion: promotion) }
               let(:payload) { { order: order, promotion: promotion, promotion_code: promotion_code } }
 
               it "should connect the adjustment to the promotion_code" do

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

@@ -84,6 +84,28 @@ describe Spree::Promotion::Rules::Product, type: :model do
         end
       end
     end
+
+    context "with an invalid match policy" do
+      let(:rule) do
+        Spree::Promotion::Rules::Product.create!(
+          promotion: create(:promotion),
+          product_promotion_rules: [
+            Spree::ProductPromotionRule.new(product: product),
+          ],
+        ).tap do |rule|
+          rule.preferred_match_policy = 'invalid'
+          rule.save!(validate: false)
+        end
+      end
+      let(:product) { order.line_items.first!.product }
+      let(:order) { create(:order_with_line_items, line_items_count: 1) }
+
+      it 'raises' do
+        expect {
+          rule.eligible?(order)
+        }.to raise_error('unexpected match policy: "invalid"')
+      end
+    end
   end
 
   describe '#actionable?' do
@@ -139,5 +161,16 @@ describe Spree::Promotion::Rules::Product, type: :model do
         it { is_expected.to be_truthy }
       end
     end
+
+    context 'with an invalid match policy' do
+      let(:rule_options) { super().merge(preferred_match_policy: 'invalid') }
+      let(:line_item) { rule_line_item }
+
+      it 'raises' do
+        expect {
+          rule.actionable?(line_item)
+        }.to raise_error('unexpected match policy: "invalid"')
+      end
+    end
   end
 end

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

@@ -1,20 +1,18 @@
 require 'spec_helper'
 
 describe Spree::Promotion::Rules::Taxon, type: :model do
-  let(:rule) { Spree::Promotion::Rules::Taxon.create!(promotion: create(:promotion)) }
+  let(:rule) do
+    Spree::Promotion::Rules::Taxon.create!(promotion: create(:promotion))
+  end
 
-  context '#elegible?(order)' do
+  context '#eligible?(order)' do
     let(:taxon){ create :taxon, name: 'first' }
     let(:taxon2){ create :taxon, name: 'second' }
     let(:order){ create :order_with_line_items }
 
-    before do
-      rule.save
-    end
-
     context 'with any match policy' do
       before do
-        rule.preferred_match_policy = 'any'
+        rule.update!(preferred_match_policy: 'any')
       end
 
       it 'is eligible if order does have any prefered taxon' do
@@ -62,7 +60,7 @@ describe Spree::Promotion::Rules::Taxon, type: :model do
 
     context 'with all match policy' do
       before do
-        rule.preferred_match_policy = 'all'
+        rule.update!(preferred_match_policy: 'all')
       end
 
       it 'is eligible order has all prefered taxons' do
@@ -98,5 +96,51 @@ describe Spree::Promotion::Rules::Taxon, type: :model do
         it{ expect(rule).to be_eligible(order) }
       end
     end
+
+    context 'with an invalid match policy' do
+      before do
+        order.products.first.taxons << taxon
+        rule.taxons << taxon
+        rule.preferred_match_policy = 'invalid'
+        rule.save!(validate: false)
+      end
+
+      it 'logs a warning and uses "any" policy' do
+        expect(Spree::Deprecation).to(
+          receive(:warn).
+          with(/has unexpected match policy "invalid"/)
+        )
+
+        expect(
+          rule.eligible?(order)
+        ).to be_truthy
+      end
+    end
+  end
+
+  describe '#actionable?' do
+    let(:line_item) { order.line_items.first! }
+    let(:order) { create :order_with_line_items }
+    let(:taxon) { create :taxon, name: 'first' }
+
+    before do
+      rule.preferred_match_policy = 'invalid'
+      rule.save!(validate: false)
+      line_item.product.taxons << taxon
+      rule.taxons << taxon
+    end
+
+    context 'with an invalid match policy' do
+      it 'logs a warning and uses "any" policy' do
+        expect(Spree::Deprecation).to(
+          receive(:warn).
+          with(/has unexpected match policy "invalid"/)
+        )
+
+        expect(
+          rule.actionable?(line_item)
+        ).to be_truthy
+      end
+    end
   end
 end

data/spec/models/spree/promotion_spec.rb

@@ -294,35 +294,35 @@ describe Spree::Promotion, type: :model do
     end
   end
 
-  context "#expired" do
+  context "#inactive" do
     it "should not be exipired" do
-      expect(promotion).not_to be_expired
+      expect(promotion).not_to be_inactive
     end
 
-    it "should be expired if it hasn't started yet" do
+    it "should be inactive if it hasn't started yet" do
       promotion.starts_at = Time.current + 1.day
-      expect(promotion).to be_expired
+      expect(promotion).to be_inactive
     end
 
-    it "should be expired if it has already ended" do
+    it "should be inactive if it has already ended" do
       promotion.expires_at = Time.current - 1.day
-      expect(promotion).to be_expired
+      expect(promotion).to be_inactive
     end
 
-    it "should not be expired if it has started already" do
+    it "should not be inactive if it has started already" do
       promotion.starts_at = Time.current - 1.day
-      expect(promotion).not_to be_expired
+      expect(promotion).not_to be_inactive
     end
 
-    it "should not be expired if it has not ended yet" do
+    it "should not be inactive if it has not ended yet" do
       promotion.expires_at = Time.current + 1.day
-      expect(promotion).not_to be_expired
+      expect(promotion).not_to be_inactive
     end
 
-    it "should not be expired if current time is within starts_at and expires_at range" do
+    it "should not be inactive if current time is within starts_at and expires_at range" do
       promotion.starts_at = Time.current - 1.day
       promotion.expires_at = Time.current + 1.day
-      expect(promotion).not_to be_expired
+      expect(promotion).not_to be_inactive
     end
   end
 
@@ -664,6 +664,12 @@ describe Spree::Promotion, type: :model do
             it { is_expected.not_to be }
           end
         end
+
+        context 'when the line item has an non-promotionable product' do
+          let(:rules) { [true_rule] }
+          let(:line_item) { build(:line_item) { |li| li.product.promotionable = false } }
+          it { is_expected.not_to be }
+        end
       end
     end
 

data/spec/models/spree/return_authorization_spec.rb

@@ -160,22 +160,6 @@ describe Spree::ReturnAuthorization, type: :model do
     end
   end
 
-  context "can_receive?" do
-    before do
-      pending "TODO: get this method into our fork"
-    end
-
-    it "should allow_receive when inventory units assigned" do
-      allow(return_authorization).to receive_messages(inventory_units: [1, 2, 3])
-      expect(return_authorization.can_receive?).to be true
-    end
-
-    it "should not allow_receive with no inventory units" do
-      allow(return_authorization).to receive_messages(inventory_units: [])
-      expect(return_authorization.can_receive?).to be false
-    end
-  end
-
   describe "#refundable_amount" do
     let(:line_item_price) { 5.0 }
     let(:line_item_count) { return_authorization.order.line_items.count }

data/spec/models/spree/shipment_spec.rb

@@ -9,21 +9,41 @@ describe Spree::Shipment, type: :model do
     order.shipments.create!(
       state: 'pending',
       cost: 1,
-      address: order.ship_address,
       inventory_units: order.inventory_units,
-      shipping_rates: [
-        Spree::ShippingRate.new(
-          shipping_method: shipping_method,
-          selected: true
-        )
-      ],
+      shipping_rates: [shipping_rate],
       stock_location: stock_location
     )
   end
+  let(:shipping_rate) do
+    Spree::ShippingRate.create!(
+      shipping_method: shipping_method,
+      selected: true
+    )
+  end
 
   let(:variant) { mock_model(Spree::Variant) }
   let(:line_item) { mock_model(Spree::LineItem, variant: variant) }
 
+  context '#transfer_to_location' do
+    it 'transfers unit to a new shipment with given location' do
+      order = create(:completed_order_with_totals, line_items_count: 2)
+      shipment = order.shipments.first
+      variant = order.inventory_units.map(&:variant).first
+
+      aggregate_failures("verifying new shipment attributes") do
+        expect do
+          shipment.transfer_to_location(variant, 1, stock_location)
+        end.to change { Spree::Shipment.count }.by(1)
+
+        new_shipment = order.shipments.last
+        expect(new_shipment.number).to_not eq(shipment.number)
+        expect(new_shipment.stock_location).to eq(stock_location)
+        expect(new_shipment.line_items.count).to eq(1)
+        expect(new_shipment.line_items.first.variant).to eq(variant)
+      end
+    end
+  end
+
   # Regression test for https://github.com/spree/spree/issues/4063
   context "number generation" do
     before { allow(order).to receive :update! }
@@ -101,6 +121,7 @@ describe Spree::Shipment, type: :model do
     it 'should equal line items final amount with tax' do
       shipment = create(:shipment, order: create(:order_with_totals))
       create :tax_adjustment, adjustable: shipment.order.line_items.first, order: shipment.order
+      shipment.order.update!
       expect(shipment.item_cost).to eql(11.0)
     end
   end
@@ -454,7 +475,7 @@ describe Spree::Shipment, type: :model do
     context "when the shipment is canceled" do
       let(:address){ create(:address) }
       let(:order){ create(:order_with_line_items, ship_address: address) }
-      let(:shipment_with_inventory_units) { create(:shipment, order: order, address: address, state: 'canceled') }
+      let(:shipment_with_inventory_units) { create(:shipment, order: order, state: 'canceled') }
       let(:subject) { shipment_with_inventory_units.ship! }
       before do
         allow(order).to receive(:update!)
@@ -565,32 +586,6 @@ describe Spree::Shipment, type: :model do
     end
   end
 
-  context "after_save" do
-    context "line item changes" do
-      before do
-        shipment.cost = shipment.cost + 10
-      end
-
-      it "triggers adjustment total recalculation" do
-        expect(shipment).to receive(:recalculate_adjustments)
-        shipment.save
-      end
-
-      it "does not trigger adjustment recalculation if shipment has shipped" do
-        shipment.state = 'shipped'
-        expect(shipment).not_to receive(:recalculate_adjustments)
-        shipment.save
-      end
-    end
-
-    context "line item does not change" do
-      it "does not trigger adjustment total recalculation" do
-        expect(shipment).not_to receive(:recalculate_adjustments)
-        shipment.save
-      end
-    end
-  end
-
   context "currency" do
     it "returns the order currency" do
       expect(shipment.currency).to eq(order.currency)
@@ -682,7 +677,6 @@ describe Spree::Shipment, type: :model do
     let(:unshippable_shipment) do
       create(
         :shipment,
-        address: create(:address),
         stock_location: stock_location,
         inventory_units: [build(:inventory_unit)]
       )
@@ -698,7 +692,7 @@ describe Spree::Shipment, type: :model do
     it 'does not send a confirmation email' do
       expect {
         unshippable_shipment.ready!
-        unshippable_shipment.inventory_units(true).each do |unit|
+        unshippable_shipment.inventory_units.reload.each do |unit|
           expect(unit.state).to eq('shipped')
         end
       }.not_to change{ ActionMailer::Base.deliveries.count }
@@ -782,4 +776,31 @@ describe Spree::Shipment, type: :model do
       expect(shipments.first).to eq(wizard_shipment)
     end
   end
+
+  describe '#selected_shipping_rate_id=' do
+    let!(:air_shipping_method) { create(:shipping_method, name: "Air") }
+    let(:new_rate) { shipment.add_shipping_method(air_shipping_method) }
+
+    context 'when the id exists' do
+      it 'sets the new shipping rate as selected' do
+        expect {
+          shipment.selected_shipping_rate_id = new_rate.id
+        }.to change { new_rate.selected }.from(false).to(true)
+      end
+
+      it 'sets the old shipping rate as not selected' do
+        expect {
+          shipment.selected_shipping_rate_id = new_rate.id
+        }.to change { shipping_rate.selected }.from(true).to(false)
+      end
+    end
+
+    context 'when the id does not exist' do
+      it 'raises a RecordNotFound error' do
+        expect {
+          shipment.selected_shipping_rate_id = -1
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
 end

data/spec/models/spree/stock/coordinator_spec.rb

@@ -26,11 +26,6 @@ module Spree
           expect(subject.shipments.size).to eq(1)
         end
 
-        it "puts the order's ship address on the shipments" do
-          shipments = subject.shipments
-          expect(shipments.map(&:address)).to eq [order.ship_address]
-        end
-
         it "builds a shipment for all active stock locations" do
           subject.shipments.count == StockLocation.count
         end

data/spec/models/spree/stock/package_spec.rb

@@ -113,7 +113,6 @@ module Spree
         expect(last_unit.state).to eq 'backordered'
 
         expect(shipment.shipping_method).to eq shipping_method
-        expect(shipment.address).to eq order.ship_address
       end
 
       it 'does not add an inventory unit to a package twice' do