spree_core 3.2.1 → 3.2.2

data/spec/lib/spree/core/controller_helpers/auth_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'spree/testing_support/url_helpers'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Auth
-  def index; render plain: 'index'; end
-end
-
-describe Spree::Core::ControllerHelpers::Auth, type: :controller do
-  controller(FakesController) {}
-  include Spree::TestingSupport::UrlHelpers
-
-  describe '#current_ability' do
-    it 'returns Spree::Ability instance' do
-      expect(controller.current_ability.class).to eq Spree::Ability
-    end
-  end
-
-  describe '#redirect_back_or_default' do
-    controller(FakesController) do
-      def index; redirect_back_or_default('/'); end
-    end
-    it 'redirects to session url' do
-      session[:spree_user_return_to] = '/redirect'
-      get :index
-      expect(response).to redirect_to('/redirect')
-    end
-    it 'redirects to HTTP_REFERER' do
-      request.env["HTTP_REFERER"] = '/dummy_redirect'
-      get :index
-      expect(response).to redirect_to('/dummy_redirect')
-    end
-    it 'redirects to default page' do
-      get :index
-      expect(response).to redirect_to('/')
-    end
-  end
-
-  describe '#set_guest_token' do
-    controller(FakesController) do
-      def index
-        set_guest_token
-        render plain: 'index'
-      end
-    end
-    it 'sends cookie header' do
-      get :index
-      expect(response.cookies['guest_token']).not_to be_nil
-    end
-  end
-
-  describe '#store_location' do
-    it 'sets session return url' do
-      allow(controller).to receive_messages(request: double(fullpath: '/redirect'))
-      controller.store_location
-      expect(session[:spree_user_return_to]).to eq '/redirect'
-    end
-  end
-
-  describe '#try_spree_current_user' do
-    it 'calls spree_current_user when define spree_current_user method' do
-      expect(controller).to receive(:spree_current_user)
-      controller.try_spree_current_user
-    end
-    it 'calls current_spree_user when define current_spree_user method' do
-      expect(controller).to receive(:current_spree_user)
-      controller.try_spree_current_user
-    end
-    it 'returns nil' do
-      expect(controller.try_spree_current_user).to eq nil
-    end
-  end
-
-  describe '#redirect_unauthorized_access' do
-    controller(FakesController) do
-      def index; redirect_unauthorized_access; end
-    end
-    context 'when logged in' do
-      before do
-        allow(controller).to receive_messages(try_spree_current_user: double('User', id: 1, last_incomplete_spree_order: nil))
-      end
-      it 'redirects forbidden path' do
-        get :index
-        expect(response).to redirect_to(spree.forbidden_path)
-      end
-    end
-    context 'when guest user' do
-      before do
-        allow(controller).to receive_messages(try_spree_current_user: nil)
-      end
-      it 'redirects login path' do
-        allow(controller).to receive_messages(spree_login_path: '/login')
-        get :index
-        expect(response).to redirect_to('/login')
-      end
-      it 'redirects root path' do
-        allow(controller).to receive_message_chain(:spree, :root_path).and_return('/root_path')
-        get :index
-        expect(response).to redirect_to('/root_path')
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Order
-end
-
-describe Spree::Core::ControllerHelpers::Order, type: :controller do
-  controller(FakesController) {}
-
-  let(:user) { create(:user) }
-  let(:order) { create(:order, user: user) }
-  let(:store) { create(:store) }
-
-  describe '#simple_current_order' do
-    before { allow(controller).to receive_messages(try_spree_current_user: user) }
-    it "returns an empty order" do
-      expect(controller.simple_current_order.item_count).to eq 0
-    end
-    it 'returns Spree::Order instance' do
-      allow(controller).to receive_messages(cookies: double(signed: { guest_token: order.guest_token }))
-      expect(controller.simple_current_order).to eq order
-    end
-  end
-
-  describe '#current_order' do
-    before {
-      allow(controller).to receive_messages(current_store: store)
-      allow(controller).to receive_messages(try_spree_current_user: user)
-    }
-    context 'create_order_if_necessary option is false' do
-      let!(:order) { create :order, user: user }
-      it 'returns current order' do
-        expect(controller.current_order).to eq order
-      end
-    end
-    context 'create_order_if_necessary option is true' do
-      it 'creates new order' do
-        expect {
-          controller.current_order(create_order_if_necessary: true)
-        }.to change(Spree::Order, :count).to(1)
-      end
-
-      it 'assigns the current_store id' do
-        controller.current_order(create_order_if_necessary: true)
-        expect(Spree::Order.last.store_id).to eq store.id
-      end
-    end
-
-    context 'gets using the guest_token' do
-      let!(:order) { create :order, user: user }
-      let!(:guest_order) { create :order, user: nil, email: nil, guest_token: 'token' }
-
-      before do
-        expect(controller).to receive(:current_order_params).and_return(
-          currency: Spree::Config[:currency], guest_token: 'token', store_id: guest_order.store_id, user_id: user.id,
-        )
-      end
-
-      specify 'without the guest token being bound to any user yet' do
-        expect(controller.current_order).to eq guest_order
-      end
-    end
-  end
-
-  describe '#associate_user' do
-    before do
-      allow(controller).to receive_messages(current_order: order, try_spree_current_user: user)
-    end
-    context "user's email is blank" do
-      let(:user) { create(:user, email: '') }
-      it 'calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-    context "user isn't blank" do
-      it 'does not calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).not_to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-  end
-
-  describe '#set_current_order' do
-    let(:incomplete_order) { create(:order, user: user) }
-    before { allow(controller).to receive_messages(try_spree_current_user: user) }
-
-    context 'when current order not equal to users incomplete orders' do
-      before { allow(controller).to receive_messages(current_order: order, last_incomplete_order: incomplete_order, cookies: double(signed: { guest_token: 'guest_token' })) }
-
-      it 'calls Spree::Order#merge! method' do
-        expect(order).to receive(:merge!).with(incomplete_order, user)
-        controller.set_current_order
-      end
-    end
-  end
-
-  describe '#current_currency' do
-    it 'returns current currency' do
-      Spree::Config[:currency] = 'USD'
-      expect(controller.current_currency).to eq 'USD'
-    end
-  end
-
-  describe '#ip_address' do
-    it 'returns remote ip' do
-      expect(controller.ip_address).to eq request.remote_ip
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/search_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Search
-end
-
-describe Spree::Core::ControllerHelpers::Search, type: :controller do
-  controller(FakesController) {}
-
-  describe '#build_searcher' do
-    it 'returns Spree::Core::Search::Base instance' do
-      allow(controller).to receive_messages(try_spree_current_user: create(:user),
-                      current_currency: 'USD')
-      expect(controller.build_searcher({}).class).to eq Spree::Core::Search::Base
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/store_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Auth
-  include Spree::Core::ControllerHelpers::Order
-  include Spree::Core::ControllerHelpers::Store
-end
-
-describe Spree::Core::ControllerHelpers::Store, type: :controller do
-  controller(FakesController) {}
-
-  describe '#current_store' do
-    let!(:store) { create :store, default: true }
-    it 'returns current store' do
-      expect(controller.current_store).to eq store
-    end
-  end
-
-  describe "#current_price_options" do
-    subject(:current_price_options) { controller.current_price_options }
-
-    context "when there is a default tax zone" do
-      let(:default_zone) { Spree::Zone.new }
-
-      before do
-        allow(Spree::Zone).to receive(:default_tax).and_return(default_zone)
-      end
-
-      context "when there is no current order" do
-        it "returns the default tax zone" do
-          is_expected.to include(tax_zone: default_zone)
-        end
-      end
-
-      context "when there is a current order" do
-        let(:other_zone) { Spree::Zone.new }
-        let(:current_order) { Spree::Order.new }
-
-        before do
-          allow(current_order).to receive(:tax_zone).and_return(other_zone)
-          allow(controller).to receive(:current_order).and_return(current_order)
-        end
-
-        it { is_expected.to include(tax_zone: other_zone) }
-      end
-    end
-
-    context "when there is no default tax zone" do
-      before do
-        allow(Spree::Zone).to receive(:default_tax).and_return(nil)
-      end
-
-      context "when there is no current order" do
-        it "return nil when asked for the current tax zone" do
-          expect(current_price_options[:tax_zone]).to be_nil
-        end
-      end
-
-      context "when there is a current order" do
-        let(:other_zone) { Spree::Zone.new }
-        let(:current_order) { Spree::Order.new }
-
-        before do
-          allow(current_order).to receive(:tax_zone).and_return(other_zone)
-          allow(controller).to receive(:current_order).and_return(current_order)
-        end
-
-        it { is_expected.to include(tax_zone: other_zone) }
-      end
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/strong_parameters_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::StrongParameters
-end
-
-describe Spree::Core::ControllerHelpers::StrongParameters, type: :controller do
-  controller(FakesController) {}
-
-  describe '#permitted_attributes' do
-    it 'returns Spree::PermittedAttributes module' do
-      expect(controller.permitted_attributes).to eq Spree::PermittedAttributes
-    end
-  end
-
-  describe '#permitted_payment_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_payment_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_checkout_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_checkout_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_order_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_order_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_product_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_product_attributes.class).to eq Array
-    end
-  end
-end

data/spec/lib/spree/core/delegate_belongs_to_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-# This is a bit of a insane spec I have to admit
-# Chosed the spree_payment_methods table because it has a `name` column
-# already. Stubs wouldn't work here (the delegation runs before this spec is
-# loaded) and adding a column here might make the test even crazy so here we go
-module Spree
-  class DelegateBelongsToStubModel < Spree::Base
-    self.table_name = "spree_payment_methods"
-    belongs_to :product
-    delegate_belongs_to :product, :name
-  end
-
-  describe DelegateBelongsToStubModel do
-    context "model has column attr delegated to associated object" do
-      it "doesnt touch the associated object" do
-        expect(subject).not_to receive(:product)
-        subject.name
-      end
-    end
-  end 
-end

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

@@ -1,605 +0,0 @@
-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!(:stock_location) { create(:stock_location, admin_name: 'Admin Name') }
-
-      let(:user) { stub_model(LegacyUser, email: 'fox@mudler.com') }
-      let(:shipping_method) { create(:shipping_method) }
-      let(:payment_method) { create(:check_payment_method) }
-
-      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) 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) 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' }
-        order = Importer::Order.import(user, params)
-        expect(order.number).to eq '123-456-789'
-      end
-
-      it 'optionally add completed at' do
-        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
-        expect(order.state).to eq 'complete'
-      end
-
-      it "assigns order[email] over user email to order" do
-        params = { email: 'wooowww@test.com' }
-        order = Importer::Order.import(user, params)
-        expect(order.email).to eq params[:email]
-      end
-
-      context "assigning a user to an order" do
-        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 }
-
-          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 = {}
-              order = Importer::Order.import(user, params)
-              expect(order.user_id).to eq(user.id)
-            end
-          end
-        end
-
-        context "as a user" do
-          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)
-            expect(order.user_id).to eq(user.id)
-          end
-        end
-      end
-
-      it 'can build an order from API with just line items' do
-        params = { line_items_attributes: line_items }
-
-        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
-        expect(line_item.quantity).to eq(5)
-        expect(line_item.variant_id).to eq(variant_id)
-      end
-
-      it 'handles line_item building exceptions' do
-        line_items.first[:variant_id] = 'XXX'
-        params = { line_items_attributes: line_items }
-
-        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/
-      end
-
-      it 'can build an order from API with variant sku' do
-        params = { line_items_attributes: [{ sku: sku, quantity: 5 }] }
-
-        order = Importer::Order.import(user, params)
-
-        line_item = order.line_items.first
-        expect(line_item.variant_id).to eq(variant_id)
-        expect(line_item.quantity).to eq(5)
-      end
-
-      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/
-      end
-
-      it 'can build an order from API shipping address' do
-        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'
-      end
-
-      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
-        }
-
-        order = Importer::Order.import(user, params)
-        expect(order.ship_address.country.iso).to eq 'US'
-      end
-
-      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
-        }
-
-        expect { Importer::Order.import(user, params) }.to raise_error /XXX/
-      end
-
-      it 'can build an order from API with state attributes' do
-        ship_address.delete(:state_id)
-        ship_address[:state] = { 'name' => state.name }
-        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 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" }
-          order = Importer::Order.import(user, params)
-          expect(order.currency).to eq "GBP"
-        end
-
-        it "can handle it when a line order price is specified" do
-          params = {
-            currency: "GBP",
-            line_items_attributes: line_items
-          }
-          line_items.first.merge! currency: "GBP", price: 1.99
-          order = Importer::Order.import(user, params)
-          expect(order.currency).to eq "GBP"
-          expect(order.line_items.first.price).to eq 1.99
-          expect(order.line_items.first.currency).to eq "GBP"
-        end
-      end
-
-      context "state passed is not associated with country" do
-        let(:params) do
-          {
-            ship_address_attributes: ship_address,
-            line_items_attributes: line_items
-          }
-        end
-
-        let(:other_state) { create(:state, name: "Uhuhuh", country: create(:country)) }
-
-        before do
-          ship_address.delete(:state_id)
-          ship_address[:state] = { 'name' => other_state.name }
-        end
-
-        it 'sets states name instead of state id' do
-          order = Importer::Order.import(user, params)
-          expect(order.ship_address.state_name).to eq other_state.name
-        end
-      end
-
-      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
-        }
-
-        order = Importer::Order.import(user, params)
-        expect(order.ship_address.state_name).to eq 'XXX'
-      end
-
-      context 'variant not deleted' do
-        it 'ensures variant id from api' do
-          hash = { sku: variant.sku }
-          Importer::Order.ensure_variant_id_from_params(hash)
-          expect(hash[:variant_id]).to eq variant.id
-        end
-      end
-
-      context 'variant was deleted' do
-        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("Ensure order import variant: Variant w/SKU #{ hash[:sku] } not found.")
-        end
-      end
-
-      it 'ensures_country_id for country fields' do
-        [:name, :iso, :iso_name, :iso3].each do |field|
-          address = { country: { field => country.send(field) } }
-          Importer::Order.ensure_country_id_from_params(address)
-          expect(address[:country_id]).to eq country.id
-        end
-      end
-
-      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/
-      end
-
-      it 'ensures_state_id for state fields' do
-        [:name, :abbr].each do |field|
-          address = { country_id: country.id, state: { field => state.send(field) } }
-          Importer::Order.ensure_state_id_from_params(address)
-          expect(address[:state_id]).to eq state.id
-        end
-      end
-
-      context "shipments" do
-        let(:params) do
-          {
-            line_items_attributes: line_items,
-            shipments_attributes: [
-              {
-                tracking: '123456789',
-                cost: '14.99',
-                shipping_method: shipping_method.name,
-                stock_location: stock_location.name,
-                inventory_units: 3.times.map { { sku: sku } }
-              },
-              {
-                tracking: '123456789',
-                cost: '14.99',
-                shipping_method: shipping_method.name,
-                stock_location: stock_location.name,
-                inventory_units: 2.times.map { { sku: sku } }
-              }
-            ]
-          }
-        end
-
-        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 }
-          Importer::Order.import(user, params)
-        end
-
-        it 'builds them properly' do
-          order = Importer::Order.import(user, params)
-          shipment = order.shipments.first
-
-          expect(shipment.cost.to_f).to eq 14.99
-          expect(shipment.inventory_units.first.variant_id).to eq product.master.id
-          expect(shipment.tracking).to eq '123456789'
-          expect(shipment.shipping_rates.first.cost).to eq 14.99
-          expect(shipment.selected_shipping_rate).to eq(shipment.shipping_rates.first)
-          expect(shipment.stock_location).to eq stock_location
-          expect(order.shipment_total.to_f).to eq 29.98
-        end
-
-        it "allocates inventory units to the correct shipments" do
-          order = Importer::Order.import(user, params)
-
-          expect(order.inventory_units.count).to eq 5
-          expect(order.shipments.first.inventory_units.count).to eq 3
-          expect(order.shipments.last.inventory_units.count).to eq 2
-        end
-
-        it "accepts admin name for stock location" do
-          params[:shipments_attributes][0][:stock_location] = stock_location.admin_name
-          order = Importer::Order.import(user, params)
-          shipment = order.shipments.first
-
-          expect(shipment.stock_location).to eq stock_location
-        end
-
-        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(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
-          let(:params) do
-            {
-              completed_at: 2.days.ago,
-              line_items_attributes: line_items,
-              shipments_attributes: [
-                {
-                  tracking: '123456789',
-                  cost: '4.99',
-                  shipped_at: 1.day.ago,
-                  shipping_method: shipping_method.name,
-                  stock_location: stock_location.name,
-                  inventory_units: [{ sku: sku }]
-                }
-              ]
-            }
-          end
-
-          it 'builds them properly' do
-            order = Importer::Order.import(user, params)
-            shipment = order.shipments.first
-
-            expect(shipment.cost.to_f).to eq 4.99
-            expect(shipment.inventory_units.first.variant_id).to eq product.master.id
-            expect(shipment.tracking).to eq '123456789'
-            expect(shipment.shipped_at).to be_present
-            expect(shipment.shipping_rates.first.cost).to eq 4.99
-            expect(shipment.selected_shipping_rate).to eq(shipment.shipping_rates.first)
-            expect(shipment.stock_location).to eq stock_location
-            expect(shipment.state).to eq('shipped')
-            expect(shipment.inventory_units.all?(&:shipped?)).to be true
-            expect(order.shipment_state).to eq('shipped')
-            expect(order.shipment_total.to_f).to eq 4.99
-          end
-        end
-      end
-
-      it 'handles shipment building exceptions' do
-        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
-            }
-          ]
-        }
-
-        order = Importer::Order.import(user, params)
-        expect(order.adjustments.all?(&:closed?)).to be true
-        expect(order.adjustments.first.label).to eq 'Shipping Discount'
-        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: [
-            { label: 'Promotion Discount', amount: -3.00 }
-          ],
-          line_items_attributes: [
-            {
-              variant_id: variant.id,
-              quantity: 5
-            }
-          ]
-        }
-
-        order = Importer::Order.import(user, params)
-        expect(order.item_total).to eq(166.1)
-        expect(order.total).to eq(163.1) # = item_total (166.1) - adjustment_total (3.00)
-      end
-
-      it 'handles adjustment building exceptions' do
-        params = {
-          adjustments_attributes: [
-            {
-              amount: 'XXX'
-            },
-            {
-              label: 'Promotion Discount',
-              amount: '-3.00'
-            }
-          ]
-        }
-
-        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'
-            }
-          ]
-        }
-        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'
-            }
-          ]
-        }
-        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 { 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"
-              }
-            }
-          ]
-        }
-
-        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 { 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
-            }
-          ]
-        }
-        order = Importer::Order.import(user, params)
-        expect(order.payments.first.created_at).to be_within(1).of created_at
-      end
-
-      context "raises error" do
-        it "clears out order from db" do
-          params = { payments_attributes: [{ payment_method: "XXX" }] }
-          count = Order.count
-
-          expect { Importer::Order.import(user, params) }.to raise_error(StandardError)
-          expect(Order.count).to eq count
-        end
-      end
-    end
-  end
-end