solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/order_spec.rb

@@ -1,17 +1,43 @@
 require 'spec_helper'
 
 class FakeCalculator < Spree::Calculator
-  def compute(computable)
+  def compute(_computable)
     5
   end
 end
 
-describe Spree::Order, :type => :model do
-  let(:user) { stub_model(Spree::LegacyUser, :email => "spree@example.com") }
-  let(:order) { stub_model(Spree::Order, :user => user) }
+describe Spree::Order, type: :model do
+  let(:store) { build_stubbed(:store) }
+  let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }
+  let(:order) { stub_model(Spree::Order, user: user, store: store) }
 
   before do
-    allow(Spree::LegacyUser).to receive_messages(:current => mock_model(Spree::LegacyUser, :id => 123))
+    allow(Spree::LegacyUser).to receive_messages(current: mock_model(Spree::LegacyUser, id: 123))
+  end
+
+  context '#store' do
+    it { is_expected.to respond_to(:store) }
+
+    context 'when there is no store assigned' do
+      subject { Spree::Order.new }
+
+      context 'when there is no default store' do
+        it "will not be valid" do
+          expect(subject).not_to be_valid
+        end
+      end
+
+      context "when there is a default store" do
+        let!(:store) { create(:store) }
+
+        it { is_expected.to be_valid }
+      end
+    end
+
+    context 'when a store is assigned' do
+      subject { Spree::Order.new(store: create(:store)) }
+      it { is_expected.to be_valid }
+    end
   end
 
   context "#canceled_by" do
@@ -46,6 +72,7 @@ describe Spree::Order, :type => :model do
   end
 
   context "#create" do
+    let!(:store) { create :store }
     let(:order) { Spree::Order.create }
 
     it "should assign an order number" do
@@ -72,9 +99,9 @@ describe Spree::Order, :type => :model do
   end
 
   context "insufficient_stock_lines" do
-    let(:line_item) { mock_model Spree::LineItem, :insufficient_stock? => true }
+    let(:line_item) { mock_model Spree::LineItem, insufficient_stock?: true }
 
-    before { allow(order).to receive_messages(:line_items => [line_item]) }
+    before { allow(order).to receive_messages(line_items: [line_item]) }
 
     it "should return line_item that has insufficient stock on hand" do
       expect(order.insufficient_stock_lines.size).to eq(1)
@@ -213,6 +240,7 @@ describe Spree::Order, :type => :model do
           def initialize(order)
             @order = order
           end
+
           def merge!(other_order, user = nil)
             [@order, other_order, user]
           end
@@ -220,10 +248,6 @@ describe Spree::Order, :type => :model do
         Spree::Config.order_merger_class = TestOrderMerger
       end
 
-      after do
-        Spree::Config.order_merger_class = Spree::PromotionChooser
-      end
-
       let(:user) { build(:user) }
 
       it 'uses the configured order merger' do
@@ -257,6 +281,7 @@ describe Spree::Order, :type => :model do
   end
 
   context "ensure shipments will be updated" do
+    subject(:order) { create :order }
     before do
       Spree::Shipment.create!(order: order)
     end
@@ -296,7 +321,6 @@ describe Spree::Order, :type => :model do
           expect { shipment.reload }.not_to raise_error
         end
       end
-
     end
 
     context 'when the order is in address state' do
@@ -368,33 +392,61 @@ describe Spree::Order, :type => :model do
         }.not_to change { order.state }
       end
     end
-
   end
 
   describe "#tax_address" do
+    let(:order) { build(:order, ship_address: ship_address, bill_address: bill_address, store: store) }
+    let(:store) { build(:store) }
+
     before { Spree::Config[:tax_using_ship_address] = tax_using_ship_address }
     subject { order.tax_address }
 
-    context "when tax_using_ship_address is true" do
-      let(:tax_using_ship_address) { true }
+    context "when the order has no addresses" do
+      let(:ship_address) { nil }
+      let(:bill_address) { nil }
+
+      context "when tax_using_ship_address is true" do
+        let(:tax_using_ship_address) { true }
 
-      it 'returns ship_address' do
-        expect(subject).to eq(order.ship_address)
+        it 'returns the stores default cart tax location' do
+          expect(subject).to eq(store.default_cart_tax_location)
+        end
+      end
+
+      context "when tax_using_ship_address is not true" do
+        let(:tax_using_ship_address) { false }
+
+        it 'returns the stores default cart tax location' do
+          expect(subject).to eq(store.default_cart_tax_location)
+        end
       end
     end
 
-    context "when tax_using_ship_address is not true" do
-      let(:tax_using_ship_address) { false }
+    context "when the order has addresses" do
+      let(:ship_address) { build(:address) }
+      let(:bill_address) { build(:address) }
+
+      context "when tax_using_ship_address is true" do
+        let(:tax_using_ship_address) { true }
+
+        it 'returns ship_address' do
+          expect(subject).to eq(order.ship_address)
+        end
+      end
+
+      context "when tax_using_ship_address is not true" do
+        let(:tax_using_ship_address) { false }
 
-      it "returns bill_address" do
-        expect(subject).to eq(order.bill_address)
+        it "returns bill_address" do
+          expect(subject).to eq(order.bill_address)
+        end
       end
     end
   end
 
   describe "#restart_checkout_flow" do
     context "when in cart state" do
-      let(:order)  { create(:order_with_totals, state: "cart") }
+      let(:order) { create(:order_with_totals, state: "cart") }
 
       it "remains in cart state" do
         expect { order.restart_checkout_flow }.not_to change { order.state }
@@ -403,13 +455,13 @@ describe Spree::Order, :type => :model do
     it "updates the state column to the first checkout_steps value" do
       order = create(:order_with_totals, state: "delivery")
       expect(order.checkout_steps).to eql ["address", "delivery", "confirm", "complete"]
-      expect{ order.restart_checkout_flow }.to change{order.state}.from("delivery").to("address")
+      expect{ order.restart_checkout_flow }.to change{ order.state }.from("delivery").to("address")
     end
 
     context "without line items" do
       it "updates the state column to cart" do
         order = create(:order, state: "delivery")
-        expect{ order.restart_checkout_flow }.to change{order.state}.from("delivery").to("cart")
+        expect{ order.restart_checkout_flow }.to change{ order.state }.from("delivery").to("cart")
       end
     end
   end
@@ -423,7 +475,7 @@ describe Spree::Order, :type => :model do
       order.payment_state = 'paid'
       expect(order.state_changes).to be_empty
       order.state_changed('payment')
-      state_change = order.state_changes.find_by(:name => 'payment')
+      state_change = order.state_changes.find_by(name: 'payment')
       expect(state_change.previous_state).to eq('balance_due')
       expect(state_change.next_state).to eq('paid')
     end
@@ -440,38 +492,53 @@ describe Spree::Order, :type => :model do
   context "#available_payment_methods" do
     it "includes frontend payment methods" do
       payment_method = Spree::PaymentMethod.create!({
-        :name => "Fake",
-        :active => true,
-        :display_on => "front_end",
+        name: "Fake",
+        active: true,
+        display_on: "front_end"
       })
       expect(order.available_payment_methods).to include(payment_method)
     end
 
     it "includes 'both' payment methods" do
       payment_method = Spree::PaymentMethod.create!({
-        :name => "Fake",
-        :active => true,
-        :display_on => "both",
+        name: "Fake",
+        active: true,
+        display_on: "both"
       })
       expect(order.available_payment_methods).to include(payment_method)
     end
 
     it "does not include a payment method twice if display_on is blank" do
       payment_method = Spree::PaymentMethod.create!({
-        :name => "Fake",
-        :active => true,
-        :display_on => "both",
+        name: "Fake",
+        active: true,
+        display_on: "both"
       })
       expect(order.available_payment_methods.count).to eq(1)
       expect(order.available_payment_methods).to include(payment_method)
     end
 
+    context "with more than one payment method" do
+      subject { order.available_payment_methods }
+
+      let!(:first_method) { FactoryGirl.create(:payment_method, display_on: :both) }
+      let!(:second_method) { FactoryGirl.create(:payment_method, display_on: :both) }
+
+      before do
+        second_method.move_to_top
+      end
+
+      it "respects the order of methods based on position" do
+        expect(subject).to eql([second_method, first_method])
+      end
+    end
+
     context 'when the order has a store' do
       let(:order) { create(:order) }
 
       let!(:store_with_payment_methods) do
         create(:store,
-          payment_methods: [payment_method_with_store],
+          payment_methods: [payment_method_with_store]
         )
       end
       let!(:payment_method_with_store) { create(:payment_method) }
@@ -503,7 +570,7 @@ describe Spree::Order, :type => :model do
   context "#apply_free_shipping_promotions" do
     it "calls out to the FreeShipping promotion handler" do
       shipment = double('Shipment')
-      allow(order).to receive_messages :shipments => [shipment]
+      allow(order).to receive_messages shipments: [shipment]
       expect(Spree::PromotionHandler::FreeShipping).to receive(:new).and_return(handler = double)
       expect(handler).to receive(:activate)
 
@@ -516,14 +583,13 @@ describe Spree::Order, :type => :model do
     end
   end
 
-
   context "#products" do
     before :each do
-      @variant1 = mock_model(Spree::Variant, :product => "product1")
-      @variant2 = mock_model(Spree::Variant, :product => "product2")
-      @line_items = [mock_model(Spree::LineItem, :product => "product1", :variant => @variant1, :variant_id => @variant1.id, :quantity => 1),
-                     mock_model(Spree::LineItem, :product => "product2", :variant => @variant2, :variant_id => @variant2.id, :quantity => 2)]
-      allow(order).to receive_messages(:line_items => @line_items)
+      @variant1 = mock_model(Spree::Variant, product: "product1")
+      @variant2 = mock_model(Spree::Variant, product: "product2")
+      @line_items = [mock_model(Spree::LineItem, product: "product1", variant: @variant1, variant_id: @variant1.id, quantity: 1),
+                     mock_model(Spree::LineItem, product: "product2", variant: @variant2, variant_id: @variant2.id, quantity: 2)]
+      allow(order).to receive_messages(line_items: @line_items)
     end
 
     it "contains?" do
@@ -533,7 +599,7 @@ describe Spree::Order, :type => :model do
     it "gets the quantity of a given variant" do
       expect(order.quantity_of(@variant1)).to eq(1)
 
-      @variant3 = mock_model(Spree::Variant, :product => "product3")
+      @variant3 = mock_model(Spree::Variant, product: "product3")
       expect(order.quantity_of(@variant3)).to eq(0)
     end
 
@@ -554,7 +620,7 @@ describe Spree::Order, :type => :model do
 
       it "matches line item when options match" do
         allow(order).to receive(:foos_match).and_return(true)
-        expect(order.line_item_options_match(@line_items.first, {foos: {bar: :zoo}})).to be true
+        expect(order.line_item_options_match(@line_items.first, { foos: { bar: :zoo } })).to be true
       end
 
       it "does not match line item without options" do
@@ -661,27 +727,27 @@ describe Spree::Order, :type => :model do
     let(:order) { Spree::Order.create }
 
     it "should be true for order in the 'complete' state" do
-      allow(order).to receive_messages(:complete? => true)
+      allow(order).to receive_messages(complete?: true)
       expect(order.can_ship?).to be true
     end
 
     it "should be true for order in the 'resumed' state" do
-      allow(order).to receive_messages(:resumed? => true)
+      allow(order).to receive_messages(resumed?: true)
       expect(order.can_ship?).to be true
     end
 
     it "should be true for an order in the 'awaiting return' state" do
-      allow(order).to receive_messages(:awaiting_return? => true)
+      allow(order).to receive_messages(awaiting_return?: true)
       expect(order.can_ship?).to be true
     end
 
     it "should be true for an order in the 'returned' state" do
-      allow(order).to receive_messages(:returned? => true)
+      allow(order).to receive_messages(returned?: true)
       expect(order.can_ship?).to be true
     end
 
     it "should be false if the order is neither in the 'complete' nor 'resumed' state" do
-      allow(order).to receive_messages(:resumed? => false, :complete? => false)
+      allow(order).to receive_messages(resumed?: false, complete?: false)
       expect(order.can_ship?).to be false
     end
   end
@@ -698,20 +764,20 @@ describe Spree::Order, :type => :model do
 
   context "#allow_checkout?" do
     it "should be true if there are line_items in the order" do
-      allow(order).to receive_message_chain(:line_items, :count => 1)
+      allow(order).to receive_message_chain(:line_items, count: 1)
       expect(order.checkout_allowed?).to be true
     end
     it "should be false if there are no line_items in the order" do
-      allow(order).to receive_message_chain(:line_items, :count => 0)
+      allow(order).to receive_message_chain(:line_items, count: 0)
       expect(order.checkout_allowed?).to be false
     end
   end
 
   context "#amount" do
     before do
-      @order = create(:order, :user => user)
-      @order.line_items = [create(:line_item, :price => 1.0, :quantity => 2),
-                           create(:line_item, :price => 1.0, :quantity => 1)]
+      @order = create(:order, user: user)
+      @order.line_items = [create(:line_item, price: 1.0, quantity: 2),
+                           create(:line_item, price: 1.0, quantity: 1)]
     end
     it "should return the correct lum sum of items" do
       expect(@order.amount).to eq(3.0)
@@ -720,8 +786,8 @@ describe Spree::Order, :type => :model do
 
   context "#backordered?" do
     it 'is backordered if one of the shipments is backordered' do
-      allow(order).to receive_messages(:shipments => [mock_model(Spree::Shipment, :backordered? => false),
-                                mock_model(Spree::Shipment, :backordered? => true)])
+      allow(order).to receive_messages(shipments: [mock_model(Spree::Shipment, backordered?: false),
+                                                   mock_model(Spree::Shipment, backordered?: true)])
       expect(order).to be_backordered
     end
   end
@@ -744,7 +810,7 @@ describe Spree::Order, :type => :model do
 
   context "#tax_total" do
     it "adds included tax and additional tax" do
-      allow(order).to receive_messages(:additional_tax_total => 10, :included_tax_total => 20)
+      allow(order).to receive_messages(additional_tax_total: 10, included_tax_total: 20)
 
       expect(order.tax_total).to eq 30
     end
@@ -762,10 +828,10 @@ describe Spree::Order, :type => :model do
   describe "#pre_tax_item_amount" do
     it "sums all of the line items' pre tax amounts" do
       subject.line_items = [
-        Spree::LineItem.new(price: 10, quantity: 2, pre_tax_amount: 5.0),
-        Spree::LineItem.new(price: 30, quantity: 1, pre_tax_amount: 14.0),
+        Spree::LineItem.new(price: 10, quantity: 2, included_tax_total: 15.0),
+        Spree::LineItem.new(price: 30, quantity: 1, included_tax_total: 16.0)
       ]
-
+      # (2*10)-15 + 30-16 = 5 + 14 = 19
       expect(subject.pre_tax_item_amount).to eq 19.0
     end
   end
@@ -820,13 +886,14 @@ 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, payment_amount: 14)}
+      let(:refund) { create(:refund, reimbursement_id: 123, amount: 5, payment_amount: 14) }
 
       it { is_expected.to eq false }
     end
   end
 
   describe "#create_proposed_shipments" do
+    subject(:order) { create(:order) }
     it "assigns the coordinator returned shipments to its shipments" do
       shipment = build(:shipment)
       allow_any_instance_of(Spree::Stock::Coordinator).to receive(:shipments).and_return([shipment])
@@ -976,7 +1043,6 @@ describe Spree::Order, :type => :model do
       end
 
       it { expect(order.fully_discounted?).to eq true }
-
     end
 
     context "the order had inventory-related cost" do
@@ -991,7 +1057,6 @@ describe Spree::Order, :type => :model do
       end
 
       it { expect(order.fully_discounted?).to eq false }
-
     end
   end
 
@@ -1005,7 +1070,7 @@ describe Spree::Order, :type => :model do
         subject { order }
 
         it "returns the sum of the payment amounts" do
-          expect(subject.total_applicable_store_credit).to eq (payment.amount + second_payment.amount)
+          expect(subject.total_applicable_store_credit).to eq(payment.amount + second_payment.amount)
         end
       end
 
@@ -1140,8 +1205,8 @@ describe Spree::Order, :type => :model do
           end
 
           it "uses the primary store credit type over the secondary" do
-            primary_payment = order.payments.detect{|x| x.source == primary_store_credit }
-            secondary_payment = order.payments.detect{|x| x.source == secondary_store_credit }
+            primary_payment = order.payments.detect{ |x| x.source == primary_store_credit }
+            secondary_payment = order.payments.detect{ |x| x.source == secondary_store_credit }
 
             expect(order.payments.size).to eq 2
             expect(primary_payment.source).to eq primary_store_credit
@@ -1229,7 +1294,7 @@ describe Spree::Order, :type => :model do
         let(:applicable_store_credit) { 10.0 }
 
         it "deducts the applicable store credit" do
-          expect(subject.order_total_after_store_credit).to eq (order_total - applicable_store_credit)
+          expect(subject.order_total_after_store_credit).to eq(order_total - applicable_store_credit)
         end
       end
 
@@ -1313,7 +1378,7 @@ describe Spree::Order, :type => :model do
       end
 
       it "returns a negative amount" do
-        expect(subject.display_total_applicable_store_credit.money.cents).to eq (total_applicable_store_credit * -100.0)
+        expect(subject.display_total_applicable_store_credit.money.cents).to eq(total_applicable_store_credit * -100.0)
       end
     end
 
@@ -1329,7 +1394,7 @@ describe Spree::Order, :type => :model do
       end
 
       it "returns the order_total_after_store_credit amount" do
-        expect(subject.display_order_total_after_store_credit.money.cents).to eq (order_total_after_store_credit * 100.0)
+        expect(subject.display_order_total_after_store_credit.money.cents).to eq(order_total_after_store_credit * 100.0)
       end
     end
 
@@ -1345,7 +1410,7 @@ describe Spree::Order, :type => :model do
       end
 
       it "returns the total_available_store_credit amount" do
-        expect(subject.display_total_available_store_credit.money.cents).to eq (total_available_store_credit * 100.0)
+        expect(subject.display_total_available_store_credit.money.cents).to eq(total_available_store_credit * 100.0)
       end
     end
 
@@ -1366,7 +1431,7 @@ describe Spree::Order, :type => :model do
 
       it "returns all of the user's available store credit minus what's applied to the order amount" do
         amount_remaining = total_available_store_credit - total_applicable_store_credit
-        expect(subject.display_store_credit_remaining_after_capture.money.cents).to eq (amount_remaining * 100.0)
+        expect(subject.display_store_credit_remaining_after_capture.money.cents).to eq(amount_remaining * 100.0)
       end
     end
 
@@ -1390,7 +1455,7 @@ describe Spree::Order, :type => :model do
             line_items_count: 1,
             # order will be $20 total:
             line_items_price: 10,
-            shipment_cost: 10,
+            shipment_cost: 10
           )
         end
 
@@ -1411,56 +1476,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

data/spec/models/spree/order_stock_location_spec.rb

@@ -13,6 +13,6 @@ module Spree
         subject
         expect(order_stock_location.reload.shipment_fulfilled).to eq(true)
       end
-    end 
+    end
   end
-end
+end

data/spec/models/spree/order_update_attributes_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Spree
   RSpec.describe OrderUpdateAttributes do
     let(:order) { create(:order) }
-    let(:payment_method) { create(:payment_method) }
     let(:request_env) { nil }
     let(:update) { described_class.new(order, attributes, request_env: request_env) }
 
@@ -15,7 +14,7 @@ module Spree
     end
 
     context 'with coupon code' do
-      let(:attributes){ {coupon_code: 'abc123'} }
+      let(:attributes){ { coupon_code: 'abc123' } }
       it "sets coupon code" do
         expect(update.apply).to be_truthy
         expect(order.coupon_code).to eq('abc123')
@@ -26,20 +25,17 @@ module Spree
       let(:attributes) do
         {
           payments_attributes: [
-            {
-              payment_method_id: payment_method.id,
-              source_attributes: attributes_for(:credit_card)
-            }
+            { source_attributes: attributes_for(:credit_card) }
           ]
         }
       end
 
       context 'with params and a request_env' do
-        let(:request_env){ {'USER_AGENT' => 'Firefox'} }
+        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'})
+          expect(order.payments[0].request_env).to eq({ 'USER_AGENT' => 'Firefox' })
         end
       end
     end
@@ -54,7 +50,7 @@ module Spree
       let(:attributes) do
         {
           shipments_attributes: {
-            0 => {selected_shipping_rate_id: shipping_method2, id: shipment.id }
+            0 => { selected_shipping_rate_id: shipping_method2, id: shipment.id }
           }
         }
       end
@@ -74,7 +70,7 @@ module Spree
         described_class.new(
           order,
           shipments_attributes: {
-            0 => {selected_shipping_rate_id: shipping_rate2.id, id: shipment.id }
+            0 => { selected_shipping_rate_id: shipping_rate2.id, id: shipment.id }
           }
         ).apply