solidus_core 1.2.3 → 1.3.0.beta1

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

@@ -1,171 +1,95 @@
 require 'spec_helper'
 
-describe Spree::Order, :type => :model do
-  let(:order) { Spree::Order.new }
-  before do
-    # Ensure state machine has been re-defined correctly
-    Spree::Order.define_state_machine!
-    # We don't care about this validation here
-    allow(order).to receive(:require_email)
-  end
+describe Spree::Order, type: :model do
+  let(:order) { create(:order_with_line_items) }
 
   context "#next!" do
     context "when current state is confirm" do
       before do
         order.state = "confirm"
-        order.run_callbacks(:create)
-        allow(order).to receive_messages :payment_required? => true
-        allow(order).to receive_messages :process_payments! => true
-        allow(order).to receive_messages :ensure_available_shipping_rates => true
+        order.save!
       end
 
       context "when payment processing succeeds" do
-        before do
-          order.payments << FactoryGirl.create(:payment, state: 'checkout', order: order)
-          allow(order).to receive_messages process_payments: true
+        let!(:payment) do
+          create(:payment, state: 'checkout', order: order)
         end
 
         it "should finalize order when transitioning to complete state" do
-          expect(order).to receive(:finalize!)
           order.complete!
+          expect(order).to be_complete
+          expect(order).to be_completed
         end
 
         context "when credit card processing fails" do
-          before { allow(order).to receive_messages :process_payments! => false }
+          let!(:payment) do
+            create(:payment, :failing, state: 'checkout', order: order)
+          end
 
           it "should not complete the order" do
-             order.next
-             expect(order.state).to eq("confirm")
-           end
-        end
-      end
-
-      context "when payment processing fails" do
-        before { allow(order).to receive_messages :process_payments! => false }
-
-        it "cannot transition to complete" do
-         order.next
-         expect(order.state).to eq("confirm")
+            expect(order.complete).to be false
+            expect(order.state).to eq("confirm")
+          end
         end
       end
     end
 
-    context "when current state is delivery" do
+    context "when current state is address" do
       before do
-        allow(order).to receive_messages :payment_required? => true
-        allow(order).to receive :apply_free_shipping_promotions
-        order.state = "delivery"
-      end
-
-      it "adjusts tax rates when transitioning to delivery" do
-        # Once for the line items
-        expect(Spree::TaxRate).to receive(:adjust).once
-        allow(order).to receive :set_shipments_cost
+        order.ensure_updated_shipments
         order.next!
+        expect(order.all_adjustments).to be_empty
+        expect(order.state).to eq "address"
       end
 
-      it "adjusts tax rates twice if there are any shipments" do
-        # Once for the line items, once for the shipments
-        order.shipments.build
-        expect(Spree::TaxRate).to receive(:adjust).twice
-        allow(order).to receive :set_shipments_cost
+      it "adjusts tax rates when transitioning to delivery" do
+        expect(Spree::Tax::OrderAdjuster).to receive(:new).once.with(order).and_call_original
         order.next!
       end
     end
   end
 
   context "#can_cancel?" do
+    let(:order) { create(:completed_order_with_totals) }
     states = [:pending, :backorder, :ready]
 
     states.each do |shipment_state|
       it "should be true if shipment_state is #{shipment_state}" do
-        allow(order).to receive_messages :completed? => true
+        expect(order).to be_completed
         order.shipment_state = shipment_state
-        expect(order.can_cancel?).to be true
+
+        expect(order).to be_can_cancel
       end
     end
 
     (Spree::Shipment.state_machine.states.keys - states).each do |shipment_state|
       it "should be false if shipment_state is #{shipment_state}" do
-        allow(order).to receive_messages :completed? => true
+        expect(order).to be_completed
         order.shipment_state = shipment_state
-        expect(order.can_cancel?).to be false
+        expect(order).not_to be_can_cancel
       end
     end
-
   end
 
   context "#cancel" do
-    let!(:variant) { stub_model(Spree::Variant) }
-    let!(:inventory_units) { [stub_model(Spree::InventoryUnit, :variant => variant),
-                              stub_model(Spree::InventoryUnit, :variant => variant) ]}
-    let!(:shipment) do
-      shipment = stub_model(Spree::Shipment)
-      allow(shipment).to receive_messages :inventory_units => inventory_units, :order => order
-      allow(order).to receive_messages :shipments => [shipment]
-      shipment
-    end
-
-    before do
-
-      2.times do
-        create(:line_item, :order => order, price: 10)
-      end
-
-      allow(order.line_items).to receive_messages :find_by_variant_id => order.line_items.first
+    let!(:order) { create(:completed_order_with_totals) }
+    let!(:shipment) { order.shipments.first }
 
-      allow(order).to receive_messages :completed? => true
-      allow(order).to receive_messages :allow_cancel? => true
-
-      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 => []
-
-      allow_any_instance_of(Spree::OrderUpdater).to receive(:update_adjustment_total) { 10 }
+    it "is setup correctly" do
+      expect(order).to be_completed
+      expect(order).to be_complete
+      expect(order).to be_allow_cancel
     end
 
     it "should send a cancel email" do
-
-      # Stub methods that cause side-effects in this test
-      allow(shipment).to receive(:cancel!)
-      allow(order).to receive :restock_items!
-      expect(Spree::OrderMailer).to receive(:cancel_email).with(order).and_return(mail_message = double)
-      expect(mail_message).to receive :deliver_later
       order.cancel!
-    end
 
-    context "restocking inventory" do
-      before do
-        allow(shipment).to receive(:ensure_correct_adjustment)
-        allow(shipment).to receive(:update_order)
-        allow(Spree::OrderMailer).to receive(:cancel_email).and_return(mail_message = double)
-        allow(mail_message).to receive :deliver_later
-
-      end
+      mail = ActionMailer::Base.deliveries.last
+      expect(mail.subject).to include "Cancellation"
     end
 
     context "resets payment state" do
-
-      let(:payment) { create(:payment, amount: order.total) }
-
-      before do
-        # TODO: This is ugly :(
-        # Stubs methods that cause unwanted side effects in this test
-        allow(Spree::OrderMailer).to receive(:cancel_email).and_return(mail_message = double)
-        allow(mail_message).to receive :deliver_later
-        allow(order).to receive :restock_items!
-        allow(shipment).to receive(:cancel!)
-        allow(payment).to receive(:cancel!)
-        allow(order).to receive_message_chain(:payments, :valid, :size).and_return(1)
-        allow(order).to receive_message_chain(:payments, :completed).and_return([payment])
-        allow(order).to receive_message_chain(:payments, :completed, :includes).and_return([payment])
-        allow(order).to receive_message_chain(:payments, :last).and_return(payment)
-        allow(order).to receive_message_chain(:payments, :store_credits, :pending).and_return([payment])
-        allow(order).to receive(:refund_total).and_return(0)
-      end
+      let!(:payment) { create(:payment, order: order, amount: order.total, state: "completed") }
 
       context "without shipped items" do
         it "should set payment state to 'void'" do
@@ -175,35 +99,20 @@ describe Spree::Order, :type => :model do
 
       context "with shipped items" do
         before do
-          allow(order).to receive_messages shipment_state: 'partial'
-          allow(order).to receive_messages outstanding_balance?: false
-          allow(order).to receive_messages payment_state: "paid"
+          order.shipments[0].ship!
         end
 
         it "should not alter the payment state" do
-          order.cancel!
+          expect(order).to_not be_allow_cancel
+          expect(order.cancel).to be false
           expect(order.payment_state).to eql "paid"
         end
       end
 
-      context "with payments" do
-        let(:payment) { create(:payment) }
-
-        it "should automatically refund all payments" do
-          expect(payment).to receive(:cancel!)
-          order.cancel!
-        end
+      it "should automatically refund all payments" do
+        expect(order).to be_allow_cancel
+        expect { order.cancel! }.to change{ payment.reload.state }.to("void")
       end
     end
   end
-
-
-  # 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"
-      allow(order).to receive_messages state: "canceled"
-      allow(order).to receive_messages allow_resume?: true
-    end
-  end
 end

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Order, :type => :model do
+  describe Spree::Order, type: :model do
     let(:order) { stub_model(Spree::Order) }
 
     context "#tax_zone" do
       let(:bill_address) { create :address }
       let(:ship_address) { create :address }
-      let(:order) { Spree::Order.create(:ship_address => ship_address, :bill_address => bill_address) }
+      let(:order) { Spree::Order.create(ship_address: ship_address, bill_address: bill_address) }
       let(:zone) { create :zone }
 
       context "when no zones exist" do
@@ -17,7 +17,7 @@ module Spree
       end
 
       context "when :tax_using_ship_address => true" do
-        before { Spree::Config.set(:tax_using_ship_address => true) }
+        before { Spree::Config.set(tax_using_ship_address: true) }
 
         it "should calculate using ship_address" do
           expect(Spree::Zone).to receive(:match).at_least(:once).with(ship_address)
@@ -27,7 +27,7 @@ module Spree
       end
 
       context "when :tax_using_ship_address => false" do
-        before { Spree::Config.set(:tax_using_ship_address => false) }
+        before { Spree::Config.set(tax_using_ship_address: false) }
 
         it "should calculate using bill_address" do
           expect(Spree::Zone).to receive(:match).at_least(:once).with(bill_address)
@@ -38,12 +38,12 @@ module Spree
 
       context "when there is a default tax zone" do
         before do
-          @default_zone = create(:zone, :name => "foo_zone")
-          allow(Spree::Zone).to receive_messages :default_tax => @default_zone
+          @default_zone = create(:zone, name: "foo_zone")
+          allow(Spree::Zone).to receive_messages default_tax: @default_zone
         end
 
         context "when there is a matching zone" do
-          before { allow(Spree::Zone).to receive_messages(:match => zone) }
+          before { allow(Spree::Zone).to receive_messages(match: zone) }
 
           it "should return the matching zone" do
             expect(order.tax_zone).to eq(zone)
@@ -51,7 +51,7 @@ module Spree
         end
 
         context "when there is no matching zone" do
-          before { allow(Spree::Zone).to receive_messages(:match => nil) }
+          before { allow(Spree::Zone).to receive_messages(match: nil) }
 
           it "should return the default tax zone" do
             expect(order.tax_zone).to eq(@default_zone)
@@ -60,10 +60,10 @@ module Spree
       end
 
       context "when no default tax zone" do
-        before { allow(Spree::Zone).to receive_messages :default_tax => nil }
+        before { allow(Spree::Zone).to receive_messages default_tax: nil }
 
         context "when there is a matching zone" do
-          before { allow(Spree::Zone).to receive_messages(:match => zone) }
+          before { allow(Spree::Zone).to receive_messages(match: zone) }
 
           it "should return the matching zone" do
             expect(order.tax_zone).to eq(zone)
@@ -71,7 +71,7 @@ module Spree
         end
 
         context "when there is no matching zone" do
-          before { allow(Spree::Zone).to receive_messages(:match => nil) }
+          before { allow(Spree::Zone).to receive_messages(match: nil) }
 
           it "should return nil" do
             expect(order.tax_zone).to be_nil
@@ -79,6 +79,5 @@ module Spree
         end
       end
     end
-
   end
 end

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Order, :type => :model do
-    let(:order) { Order.create }
+  describe Order, type: :model do
+    let(:order) { create(:order) }
     let(:shirt) { create(:variant) }
 
     context "adds item to cart and activates promo" do
       let(:promotion) { Promotion.create name: 'Huhu', apply_automatically: true }
-      let(:calculator) { Calculator::FlatPercentItemTotal.new(:preferred_flat_percent => 10) }
+      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
       let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
 
       before { order.contents.add(shirt, 1) }

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

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Spree::Order, :type => :model do
+describe Spree::Order, type: :model do
   let(:order) { stub_model(Spree::Order) }
 
   context "#update!" do
-    let(:line_items) { [mock_model(Spree::LineItem, :amount => 5) ]}
+    let(:line_items) { [mock_model(Spree::LineItem, amount: 5)] }
 
     context "when there are update hooks" do
       before { Spree::Order.register_update_hook :foo }

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Order, :type => :model do
+  describe Spree::Order, type: :model do
     context "validations" do
       # 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)
+        allow(order).to receive_messages(require_email: true)
         order.valid?
         expect(order.errors[:email]).to eq(["can't be blank"])
       end

data/spec/models/spree/order_cancellations_spec.rb

@@ -153,7 +153,7 @@ describe Spree::OrderCancellations do
       it "generates the correct total amount" do
         order.cancellations.short_ship([inventory_unit_1])
         order.cancellations.short_ship([inventory_unit_2])
-        expect(line_item.adjustments.non_tax.sum(:amount)).to eq -1.67
+        expect(line_item.adjustments.non_tax.sum(:amount)).to eq(-1.67)
         expect(line_item.total).to eq 0
       end
     end

data/spec/models/spree/order_capturing_spec.rb

@@ -135,7 +135,7 @@ describe Spree::OrderCapturing do
         let(:payment_methods) { [Spree::Gateway::Bogus, ExceptionallyBogusPaymentMethod] }
 
         class ExceptionallyBogusPaymentMethod < Spree::Gateway::Bogus
-          def capture(*args)
+          def capture(*_args)
             raise ActiveMerchant::ConnectionError.new("foo", nil)
           end
         end

data/spec/models/spree/order_contents_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
-describe Spree::OrderContents, :type => :model do
+describe Spree::OrderContents, type: :model do
+  let!(:store) { create :store }
   let(:order) { Spree::Order.create }
   let(:variant) { create(:variant) }
   let!(:stock_location) { variant.stock_locations.first }
@@ -57,7 +58,7 @@ describe Spree::OrderContents, :type => :model do
     end
 
     it "should create stock location associations if provided" do
-      line_item = subject.add(variant, 3, stock_location_quantities: {stock_location.id => 1, stock_location_2.id => 2})
+      line_item = subject.add(variant, 3, stock_location_quantities: { stock_location.id => 1, stock_location_2.id => 2 })
       order_stock_locations = line_item.order.order_stock_locations
       expect(order_stock_locations.count).to eq(2)
       expect(order_stock_locations.map(&:quantity)).to eq([1, 2])
@@ -66,7 +67,7 @@ describe Spree::OrderContents, :type => :model do
 
     context "running promotions" do
       let(:promotion) { create(:promotion, apply_automatically: true) }
-      let(:calculator) { Spree::Calculator::FlatRate.new(:preferred_amount => 10) }
+      let(:calculator) { Spree::Calculator::FlatRate.new(preferred_amount: 10) }
 
       shared_context "discount changes order total" do
         before { subject.add(variant, 1) }
@@ -117,7 +118,7 @@ describe Spree::OrderContents, :type => :model do
 
     context 'given a shipment' do
       it "ensure shipment calls update_amounts instead of order calling ensure_updated_shipments" do
-        line_item = subject.add(variant, 1)
+        subject.add(variant, 1)
         shipment = create(:shipment)
         expect(subject.order).to_not receive(:ensure_updated_shipments)
         expect(shipment).to receive(:update_amounts)
@@ -127,7 +128,7 @@ describe Spree::OrderContents, :type => :model do
 
     context 'not given a shipment' do
       it "ensures updated shipments" do
-        line_item = subject.add(variant, 1)
+        subject.add(variant, 1)
         expect(subject.order).to receive(:ensure_updated_shipments)
         subject.remove(variant)
       end
@@ -151,12 +152,12 @@ describe Spree::OrderContents, :type => :model do
       expect(order.item_total.to_f).to eq(0.00)
       expect(order.total.to_f).to eq(0.00)
 
-      subject.add(variant,2)
+      subject.add(variant, 2)
 
       expect(order.item_total.to_f).to eq(39.98)
       expect(order.total.to_f).to eq(39.98)
 
-      subject.remove(variant,1)
+      subject.remove(variant, 1)
       expect(order.item_total.to_f).to eq(19.99)
       expect(order.total.to_f).to eq(19.99)
     end
@@ -192,7 +193,7 @@ describe Spree::OrderContents, :type => :model do
       expect(order.item_total.to_f).to eq(0.00)
       expect(order.total.to_f).to eq(0.00)
 
-      line_item = subject.add(variant,2)
+      line_item = subject.add(variant, 2)
 
       expect(order.item_total.to_f).to eq(39.98)
       expect(order.total.to_f).to eq(39.98)
@@ -203,7 +204,6 @@ describe Spree::OrderContents, :type => :model do
     end
   end
 
-
   context "update cart" do
     let!(:shirt) { subject.add variant, 1 }
 
@@ -227,7 +227,7 @@ describe Spree::OrderContents, :type => :model do
     context "submits item quantity 0" do
       let(:params) do
         { line_items_attributes: {
-          "0" => { id: shirt.id, quantity: 0 },
+          "0" => { id: shirt.id, quantity: 0 }
         } }
       end
 
@@ -303,5 +303,4 @@ describe Spree::OrderContents, :type => :model do
       end
     end
   end
-
 end

data/spec/models/spree/order_inventory_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::OrderInventory, :type => :model do
+describe Spree::OrderInventory, type: :model do
   let(:order) { create :completed_order_with_totals }
   let(:line_item) { order.line_items.first }
 
@@ -91,9 +91,9 @@ describe Spree::OrderInventory, :type => :model do
     before do
       subject.verify
 
-      order.shipments.create(:stock_location_id => stock_location.id, :cost => 5)
+      order.shipments.create(stock_location_id: stock_location.id, cost: 5)
 
-      shipped = order.shipments.create(:stock_location_id => order.shipments.first.stock_location.id, :cost => 10)
+      shipped = order.shipments.create(stock_location_id: order.shipments.first.stock_location.id, cost: 10)
       shipped.update_column(:state, 'shipped')
     end
 
@@ -164,9 +164,9 @@ describe Spree::OrderInventory, :type => :model do
 
       it 'should destroy backordered units first' do
         allow(shipment).to receive_messages(inventory_units_for_item: [
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'backordered'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'backordered')
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'backordered'),
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'on_hand'),
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'backordered')
         ])
 
         expect(shipment.inventory_units_for_item[0]).to receive(:destroy)
@@ -178,8 +178,8 @@ describe Spree::OrderInventory, :type => :model do
 
       it 'should destroy unshipped units first' do
         allow(shipment).to receive_messages(inventory_units_for_item: [
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'shipped'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand')
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'shipped'),
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'on_hand')
         ])
 
         expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
@@ -190,8 +190,8 @@ describe Spree::OrderInventory, :type => :model do
 
       it 'only attempts to destroy as many units as are eligible, and return amount destroyed' do
         allow(shipment).to receive_messages(inventory_units_for_item: [
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'shipped'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand')
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'shipped'),
+          mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'on_hand')
         ])
 
         expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
@@ -201,7 +201,7 @@ describe Spree::OrderInventory, :type => :model do
       end
 
       it 'should destroy self if not inventory units remain' do
-        allow(shipment.inventory_units).to receive_messages(:count => 0)
+        allow(shipment.inventory_units).to receive_messages(count: 0)
         expect(shipment).to receive(:destroy)
 
         expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)

data/spec/models/spree/order_merger_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 module Spree
   describe OrderMerger, type: :model do
     let(:variant) { create(:variant) }
+    let!(:store) { create(:store, default: true) }
     let(:order_1) { Spree::Order.create }
     let(:order_2) { Spree::Order.create }
     let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }

data/spec/models/spree/order_shipping_spec.rb

@@ -8,7 +8,6 @@ describe Spree::OrderShipping do
   end
 
   shared_examples 'shipment shipping' do
-
     it "marks the inventory units as shipped" do
       expect { subject }.to change { order.inventory_units.reload.map(&:state) }.from(['on_hand']).to(['shipped'])
     end
@@ -43,7 +42,6 @@ describe Spree::OrderShipping do
         end
       end.to change { order.updated_at }.from(order.updated_at).to(future)
     end
-
   end
 
   describe "#ship" do
@@ -52,7 +50,7 @@ describe Spree::OrderShipping do
         inventory_units: inventory_units,
         stock_location: stock_location,
         address: address,
-        shipping_method: shipping_method,
+        shipping_method: shipping_method
       )
     end
 
@@ -71,7 +69,7 @@ describe Spree::OrderShipping do
           stock_location: stock_location,
           address: address,
           shipping_method: shipping_method,
-          external_number: 'some-external-number',
+          external_number: 'some-external-number'
         )
       end
 
@@ -87,7 +85,7 @@ describe Spree::OrderShipping do
           stock_location: stock_location,
           address: address,
           shipping_method: shipping_method,
-          tracking_number: 'tracking-number',
+          tracking_number: 'tracking-number'
         )
       end
 
@@ -103,7 +101,7 @@ describe Spree::OrderShipping do
           stock_location: stock_location,
           address: address,
           shipping_method: shipping_method,
-          suppress_mailer: true,
+          suppress_mailer: true
         )
       end
 
@@ -148,7 +146,7 @@ describe Spree::OrderShipping do
       subject do
         order.shipping.ship_shipment(
           shipment,
-          external_number: 'some-external-number',
+          external_number: 'some-external-number'
         )
       end
 
@@ -161,7 +159,7 @@ describe Spree::OrderShipping do
       subject do
         order.shipping.ship_shipment(
           shipment,
-          tracking_number: 'tracking-number',
+          tracking_number: 'tracking-number'
         )
       end
 
@@ -193,7 +191,7 @@ describe Spree::OrderShipping do
           inventory_units: shipped_inventory,
           stock_location: shipment.stock_location,
           address: shipment.address,
-          shipping_method: shipment.shipping_method,
+          shipping_method: shipment.shipping_method
         )
       end
 
@@ -211,7 +209,7 @@ describe Spree::OrderShipping do
       subject do
         order.shipping.ship_shipment(
           shipment,
-          suppress_mailer: true,
+          suppress_mailer: true
         )
       end