spree_core 3.0.10 → 3.1.0.rc1

data/spec/lib/spree/core/importer/order_spec.rb

@@ -3,40 +3,45 @@ require 'spec_helper'
 module Spree
   module Core
     describe Importer::Order do
-
       let!(:country) { create(:country) }
-      let!(:state) { country.states.first || create(:state, :country => country) }
+      let!(:state) { country.states.first || create(:state, country: country) }
       let!(:stock_location) { create(:stock_location, admin_name: 'Admin Name') }
 
-      let(:user) { stub_model(LegacyUser, :email => 'fox@mudler.com') }
+      let(:user) { stub_model(LegacyUser, email: 'fox@mudler.com') }
       let(:shipping_method) { create(:shipping_method) }
       let(:payment_method) { create(:check_payment_method) }
 
-      let(:product) { product = Spree::Product.create(:name => 'Test',
-                                             :sku => 'TEST-1',
-                                             :price => 33.22)
-                      product.shipping_category = create(:shipping_category)
-                      product.save
-                      product }
+      let(:product) do
+        product = Spree::Product.create(name: 'Test',
+                                        sku: 'TEST-1',
+                                        price: 33.22, available_on: Time.current - 1.day)
+        product.shipping_category = create(:shipping_category)
+        product.save
+        product
+      end
 
-      let(:variant) { variant = product.master
-                      variant.stock_items.each { |si| si.update_attribute(:count_on_hand, 10) }
-                      variant }
+      let(:variant) do
+        variant = product.master
+        variant.stock_items.each { |si| si.update_attribute(:count_on_hand, 10) }
+        variant
+      end
 
       let(:sku) { variant.sku }
       let(:variant_id) { variant.id }
 
       let(:line_items) { [{ variant_id: variant.id, quantity: 5 }] }
-      let(:ship_address) {{
-         :address1 => '123 Testable Way',
-         :firstname => 'Fox',
-         :lastname => 'Mulder',
-         :city => 'Washington',
-         :country_id => country.id,
-         :state_id => state.id,
-         :zipcode => '66666',
-         :phone => '666-666-6666'
-      }}
+      let(:ship_address) do
+        {
+          address1: '123 Testable Way',
+          firstname: 'Fox',
+          lastname: 'Mulder',
+          city: 'Washington',
+          country_id: country.id,
+          state_id: state.id,
+          zipcode: '66666',
+          phone: '666-666-6666'
+        }
+      end
 
       it 'can import an order number' do
         params = { number: '123-456-789' }
@@ -45,9 +50,11 @@ module Spree
       end
 
       it 'optionally add completed at' do
-        params = { email: 'test@test.com',
-                   completed_at: Time.now,
-                   line_items_attributes: line_items }
+        params = {
+          email: 'test@test.com',
+          completed_at: Time.current,
+          line_items_attributes: line_items
+        }
 
         order = Importer::Order.import(user, params)
         expect(order).to be_completed
@@ -61,15 +68,15 @@ module Spree
       end
 
       context "assigning a user to an order" do
-        let(:other_user) { stub_model(LegacyUser, :email => 'dana@scully.com') }
+        let(:other_user) { stub_model(LegacyUser, email: 'dana@scully.com') }
 
         context "as an admin" do
-          before { allow(user).to receive_messages :has_spree_role? => true }
+          before { allow(user).to receive_messages has_spree_role?: true }
 
           context "a user's id is not provided" do
             # this is a regression spec for an issue we ran into at Bonobos
             it "doesn't unassociate the admin from the order" do
-              params = { }
+              params = {}
               order = Importer::Order.import(user, params)
               expect(order.user_id).to eq(user.id)
             end
@@ -77,7 +84,7 @@ module Spree
         end
 
         context "as a user" do
-          before { allow(user).to receive_messages :has_spree_role? => false }
+          before { allow(user).to receive_messages has_spree_role?: false }
           it "does not assign the order to the other user" do
             params = { user_id: other_user.id }
             order = Importer::Order.import(user, params)
@@ -87,9 +94,10 @@ module Spree
       end
 
       it 'can build an order from API with just line items' do
-        params = { :line_items_attributes => line_items }
+        params = { line_items_attributes: line_items }
 
-        expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_return({variant_id: variant.id, quantity: 5})
+        expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_return(variant_id: variant.id,
+                                                                                      quantity: 5)
         order = Importer::Order.import(user, params)
         expect(order.user).to eq(nil)
         line_item = order.line_items.first
@@ -101,18 +109,14 @@ module Spree
         line_items.first[:variant_id] = 'XXX'
         params = { line_items_attributes: line_items }
 
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /XXX/
+        expect { Importer::Order.import(user, params) }.to raise_error /XXX/
       end
 
       it 'handles line_item updating exceptions' do
         line_items.first[:currency] = 'GBP'
         params = { line_items_attributes: line_items }
 
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /Validation failed/
+        expect { Importer::Order.import(user, params) }.to raise_error /Validation failed/
       end
 
       it 'can build an order from API with variant sku' do
@@ -127,14 +131,14 @@ module Spree
 
       it 'handles exceptions when sku is not found' do
         params = { line_items_attributes: [{ sku: 'XXX', quantity: 5 }] }
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /XXX/
+        expect { Importer::Order.import(user, params) }.to raise_error /XXX/
       end
 
       it 'can build an order from API shipping address' do
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = {
+          ship_address_attributes: ship_address,
+          line_items_attributes: line_items
+        }
 
         order = Importer::Order.import(user, params)
         expect(order.ship_address.address1).to eq '123 Testable Way'
@@ -143,8 +147,10 @@ module Spree
       it 'can build an order from API with country attributes' do
         ship_address.delete(:country_id)
         ship_address[:country] = { 'iso' => 'US' }
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = {
+          ship_address_attributes: ship_address,
+          line_items_attributes: line_items
+        }
 
         order = Importer::Order.import(user, params)
         expect(order.ship_address.country.iso).to eq 'US'
@@ -153,12 +159,12 @@ module Spree
       it 'handles country lookup exceptions' do
         ship_address.delete(:country_id)
         ship_address[:country] = { 'iso' => 'XXX' }
-        params = { ship_address_attributes: ship_address,
-                   line_items_attributes: line_items }
+        params = {
+          ship_address_attributes: ship_address,
+          line_items_attributes: line_items
+        }
 
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /XXX/
+        expect { Importer::Order.import(user, params) }.to raise_error /XXX/
       end
 
       it 'can build an order from API with state attributes' do
@@ -170,16 +176,14 @@ module Spree
         }
 
         order = Importer::Order.import(user, params)
-        expect(order.ship_address.state.name).to eq 'Alabama'
+        expect(order.ship_address.state.name).to eq state.name
       end
 
       context "with a different currency" do
         before { variant.price_in("GBP").update_attribute(:price, 18.99) }
 
         it "sets the order currency" do
-          params = {
-            currency: "GBP"
-          }
+          params = { currency: "GBP" }
           order = Importer::Order.import(user, params)
           expect(order.currency).to eq "GBP"
         end
@@ -221,8 +225,10 @@ module Spree
       it 'sets state name if state record not found' do
         ship_address.delete(:state_id)
         ship_address[:state] = { 'name' => 'XXX' }
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = {
+          ship_address_attributes: ship_address,
+          line_items_attributes: line_items
+        }
 
         order = Importer::Order.import(user, params)
         expect(order.ship_address.state_name).to eq 'XXX'
@@ -240,9 +246,7 @@ module Spree
         it 'raise error as variant shouldnt be found' do
           variant.product.destroy
           hash = { sku: variant.sku }
-          expect {
-            Importer::Order.ensure_variant_id_from_params(hash)
-          }.to raise_error
+          expect { Importer::Order.ensure_variant_id_from_params(hash) }.to raise_error("Ensure order import variant: Variant w/SKU #{ hash[:sku] } not found.")
         end
       end
 
@@ -256,9 +260,7 @@ module Spree
 
       it "raises with proper message when cant find country" do
         address = { country: { "name" => "NoNoCountry" } }
-        expect {
-          Importer::Order.ensure_country_id_from_params(address)
-        }.to raise_error /NoNoCountry/
+        expect { Importer::Order.ensure_country_id_from_params(address) }.to raise_error /NoNoCountry/
       end
 
       it 'ensures_state_id for state fields' do
@@ -294,7 +296,7 @@ module Spree
 
         it 'ensures variant exists and is not deleted' do
           expect(Importer::Order).to receive(:ensure_variant_id_from_params).exactly(6).times { line_items.first }
-          order = Importer::Order.import(user, params)
+          Importer::Order.import(user, params)
         end
 
         it 'builds them properly' do
@@ -328,9 +330,19 @@ module Spree
 
         it "raises if cant find stock location" do
           params[:shipments_attributes][0][:stock_location] = "doesnt exist"
-          expect {
-            Importer::Order.import(user, params)
-          }.to raise_error
+          expect { Importer::Order.import(user, params) }.to raise_error(StandardError)
+        end
+
+        context 'when a shipping adjustment is present' do
+          it 'creates the shipping adjustment' do
+            adjustment_attributes = [{ label: 'Shipping Discount', amount: -5.00 }]
+            params[:shipments_attributes][0][:adjustments_attributes] = adjustment_attributes
+            order = Importer::Order.import(user, params)
+            shipment = order.shipments.first
+
+            expect(shipment.adjustments.first.label).to eq('Shipping Discount')
+            expect(shipment.adjustments.first.amount).to eq(-5.00)
+          end
         end
 
         context 'when completed_at and shipped_at present' do
@@ -339,7 +351,8 @@ module Spree
               completed_at: 2.days.ago,
               line_items_attributes: line_items,
               shipments_attributes: [
-                { tracking: '123456789',
+                {
+                  tracking: '123456789',
                   cost: '4.99',
                   shipped_at: 1.day.ago,
                   shipping_method: shipping_method.name,
@@ -370,18 +383,31 @@ module Spree
       end
 
       it 'handles shipment building exceptions' do
-        params = { :shipments_attributes => [{ tracking: '123456789',
-                                               cost: '4.99',
-                                               shipping_method: 'XXX',
-                                               inventory_units: [{ sku: sku }]
-                                             }] }
+        params = {
+          shipments_attributes: [
+            {
+              tracking: '123456789',
+              cost: '4.99',
+              shipping_method: 'XXX',
+              inventory_units: [{ sku: sku }]
+            }
+          ]
+        }
         expect { Importer::Order.import(user, params) }.to raise_error /XXX/
       end
 
       it 'adds adjustments' do
-        params = { adjustments_attributes: [
-            { label: 'Shipping Discount', amount: -4.99 },
-            { label: 'Promotion Discount', amount: -3.00 }]
+        params = {
+          adjustments_attributes: [
+            {
+              label: 'Shipping Discount',
+              amount: -4.99
+            },
+            {
+              label: 'Promotion Discount',
+              amount: -3.00
+            }
+          ]
         }
 
         order = Importer::Order.import(user, params)
@@ -390,6 +416,49 @@ module Spree
         expect(order.adjustments.first.amount).to eq -4.99
       end
 
+      it 'adds line item adjustments from promotion' do
+        line_items.first[:adjustments_attributes] = [
+          {
+            label: 'Line Item Discount',
+            amount: -4.99,
+            promotion: true
+          }
+        ]
+        params = {
+          line_items_attributes: line_items,
+          adjustments_attributes: [
+            { label: 'Order Discount', amount: -5.99 }
+          ]
+        }
+
+        order = Importer::Order.import(user, params)
+        line_item_adjustment = order.line_item_adjustments.first
+        expect(line_item_adjustment.closed?).to be true
+        expect(line_item_adjustment.label).to eq 'Line Item Discount'
+        expect(line_item_adjustment.amount).to eq -4.99
+        expect(order.line_items.first.adjustment_total).to eq -4.99
+      end
+
+      it 'adds line item adjustments from taxation' do
+        line_items.first[:adjustments_attributes] = [
+          { label: 'Line Item Tax', amount: -4.99, tax: true }
+        ]
+        params = {
+          line_items_attributes: line_items,
+          adjustments_attributes: [
+            { label: 'Order Discount', amount: -5.99 }
+          ]
+        }
+
+        order = Importer::Order.import(user, params)
+
+        line_item_adjustment = order.line_item_adjustments.first
+        expect(line_item_adjustment.closed?).to be true
+        expect(line_item_adjustment.label).to eq 'Line Item Tax'
+        expect(line_item_adjustment.amount).to eq -4.99
+        expect(order.line_items.first.adjustment_total).to eq -4.99
+      end
+
       it "calculates final order total correctly" do
         params = {
           adjustments_attributes: [
@@ -409,80 +478,115 @@ module Spree
       end
 
       it 'handles adjustment building exceptions' do
-        params = { adjustments_attributes: [
-            { amount: 'XXX' },
-            { label: 'Promotion Discount', amount: '-3.00' }] }
+        params = {
+          adjustments_attributes: [
+            {
+              amount: 'XXX'
+            },
+            {
+              label: 'Promotion Discount',
+              amount: '-3.00'
+            }
+          ]
+        }
 
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /XXX/
+        expect { Importer::Order.import(user, params) }.to raise_error /XXX/
       end
 
       it 'builds a payment using state' do
-        params = { payments_attributes: [{ amount: '4.99',
-                                           payment_method: payment_method.name,
-                                           state: 'completed' }] }
+        params = {
+          payments_attributes: [
+            {
+              amount: '4.99',
+              payment_method: payment_method.name,
+              state: 'completed'
+            }
+          ]
+        }
         order = Importer::Order.import(user, params)
         expect(order.payments.first.amount).to eq 4.99
       end
 
       it 'builds a payment using status as fallback' do
-        params = { payments_attributes: [{ amount: '4.99',
-                                           payment_method: payment_method.name,
-                                           status: 'completed' }] }
+        params = {
+          payments_attributes: [
+            {
+              amount: '4.99',
+              payment_method: payment_method.name,
+              status: 'completed'
+            }
+          ]
+        }
         order = Importer::Order.import(user, params)
         expect(order.payments.first.amount).to eq 4.99
       end
 
       it 'handles payment building exceptions' do
-        params = { payments_attributes: [{ amount: '4.99',
-                                           payment_method: 'XXX' }] }
-        expect {
-          order = Importer::Order.import(user, params)
-        }.to raise_error /XXX/
+        params = {
+          payments_attributes: [
+            {
+              amount: '4.99',
+              payment_method: 'XXX'
+            }
+          ]
+        }
+        expect { Importer::Order.import(user, params) }.to raise_error /XXX/
       end
 
       it 'build a source payment using years and month' do
-        params = { payments_attributes: [{
-                                          amount: '4.99',
-                                          payment_method: payment_method.name,
-                                          status: 'completed',
-                                          source: {
-                                            name: 'Fox',
-                                            last_digits: "7424",
-                                            cc_type: "visa",
-                                            year: '2022',
-                                            month: "5"
-                                          }
-                                        }] }
+        params = {
+          payments_attributes: [
+            {
+              amount: '4.99',
+              payment_method: payment_method.name,
+              status: 'completed',
+              source: {
+                name: 'Fox',
+                last_digits: "7424",
+                cc_type: "visa",
+                year: '2022',
+                month: "5"
+              }
+            }
+          ]
+        }
 
         order = Importer::Order.import(user, params)
         expect(order.payments.first.source.last_digits).to eq '7424'
       end
 
       it 'handles source building exceptions when do not have years and month' do
-        params = { payments_attributes: [{
-                                          amount: '4.99',
-                                          payment_method: payment_method.name,
-                                          status: 'completed',
-                                          source: {
-                                            name: 'Fox',
-                                            last_digits: "7424",
-                                            cc_type: "visa"
-                                          }
-                                        }] }
-
-        expect {
-          order = Importer::Order.import(user, params)
-        }.to raise_error /Validation failed: Credit card Month is not a number, Credit card Year is not a number/
+        params = {
+          payments_attributes: [
+            {
+              amount: '4.99',
+              payment_method: payment_method.name,
+              status: 'completed',
+              source: {
+                name: 'Fox',
+                last_digits: "7424",
+                cc_type: "visa"
+              }
+            }
+          ]
+        }
+
+        expect { Importer::Order.import(user, params) }.
+          to raise_error /Validation failed: Credit card Month is not a number, Credit card Year is not a number/
       end
 
       it 'builds a payment with an optional created_at' do
         created_at = 2.days.ago
-        params = { payments_attributes: [{ amount: '4.99',
-                                           payment_method: payment_method.name,
-                                           state: 'completed',
-                                           created_at: created_at }] }
+        params = {
+          payments_attributes: [
+            {
+              amount: '4.99',
+              payment_method: payment_method.name,
+              state: 'completed',
+              created_at: created_at
+            }
+          ]
+        }
         order = Importer::Order.import(user, params)
         expect(order.payments.first.created_at).to be_within(0.1).of created_at
       end
@@ -492,11 +596,10 @@ module Spree
           params = { payments_attributes: [{ payment_method: "XXX" }] }
           count = Order.count
 
-          expect { Importer::Order.import(user, params) }.to raise_error
+          expect { Importer::Order.import(user, params) }.to raise_error(StandardError)
           expect(Order.count).to eq count
         end
       end
-
     end
   end
 end