solidus_backend 2.10.3 → 2.11.0

data/spec/controllers/spree/admin/customer_returns_controller_spec.rb

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe CustomerReturnsController, type: :controller do
-      stub_authorization!
-
-      describe "#index" do
-        let(:order)           { customer_return.order }
-        let(:customer_return) { create(:customer_return) }
-
-        subject do
-          get :index, params: { order_id: customer_return.order.to_param }
-        end
-
-        before { subject }
-
-        it "loads the order" do
-          expect(assigns(:order)).to eq order
-        end
-
-        it "loads the customer return" do
-          expect(assigns(:customer_returns)).to include(customer_return)
-        end
-      end
-
-      describe "#new" do
-        let(:order) { create(:shipped_order, line_items_count: 1) }
-        let!(:inactive_reimbursement_type)      { create(:reimbursement_type, active: false) }
-        let!(:first_active_reimbursement_type)  { create(:reimbursement_type) }
-        let!(:second_active_reimbursement_type) { create(:reimbursement_type) }
-
-        subject do
-          get :new, params: { order_id: order.to_param }
-        end
-
-        it "loads the order" do
-          subject
-          expect(assigns(:order)).to eq order
-        end
-
-        it "builds a new customer return" do
-          subject
-          expect(assigns(:customer_return)).to_not be_persisted
-        end
-
-        context "with previous customer return" do
-          let(:return_reason_1) { create(:return_reason) }
-          let(:return_reason_2) { create(:return_reason) }
-          let(:return_reason_3) { create(:return_reason) }
-          let!(:inactive_rma_reason) { create(:return_reason, active: false) }
-
-          let(:order) { create(:shipped_order, line_items_count: 4) }
-          let(:rma) { create(:return_authorization, order: order, reason: return_reason_1) }
-
-          let!(:rma_return_item) { create(:return_item, return_authorization: rma, inventory_unit: order.inventory_units.first, return_reason: return_reason_2) }
-          let!(:customer_return_return_item) { create(:return_item, return_authorization: nil, inventory_unit: order.inventory_units.last, return_reason: return_reason_3) }
-
-          context "all return items are associated with a customer return" do
-            let!(:previous_customer_return) { create(:customer_return_without_return_items, return_items: [rma_return_item, customer_return_return_item]) }
-
-            before { subject }
-
-            it "loads the possible return items" do
-              total_inventory_count = 4
-              rma_return_items_count = 1
-              customer_return_return_items_count = 1
-              expect(assigns(:new_return_items).length).to eq(total_inventory_count - rma_return_items_count - customer_return_return_items_count)
-            end
-
-            it "builds new return items" do
-              expect(assigns(:new_return_items).all? { |return_item| !return_item.persisted? }).to eq true
-            end
-
-            it "does not have any rma return items" do
-              expect(assigns(:rma_return_items)).to eq []
-            end
-
-            it "loads the correct return authorization reasons" do
-              expect(assigns(:reasons)).to match_array([return_reason_1, return_reason_2, return_reason_3])
-            end
-          end
-
-          context "there is a return item associated with an rma but not a customer return" do
-            let!(:previous_customer_return) { create(:customer_return_without_return_items, return_items: [customer_return_return_item]) }
-
-            before do
-              subject
-            end
-
-            it "loads the possible return items" do
-              rma_return_item_count = rma.return_items.count
-              total_unit_count = order.inventory_units.count
-              customer_returned_count = previous_customer_return.return_items.count
-              expected_total = total_unit_count - customer_returned_count - rma_return_item_count
-              expect(assigns(:new_return_items).length).to eq expected_total
-            end
-
-            it "builds new return items" do
-              expect(assigns(:new_return_items).all? { |return_item| !return_item.persisted? }).to eq true
-            end
-
-            it "loads the persisted rma return items" do
-              expect(assigns(:rma_return_items).all?(&:persisted?)).to eq true
-            end
-
-            it "has one rma return item" do
-              expect(assigns(:rma_return_items)).to include(rma_return_item)
-            end
-
-            it "loads the correct return authorization reasons" do
-              expect(assigns(:reasons)).to match_array([return_reason_1, return_reason_2, return_reason_3])
-            end
-          end
-        end
-      end
-
-      describe "#edit" do
-        let(:order)           { customer_return.order }
-        let(:customer_return) { create(:customer_return, line_items_count: 3) }
-
-        let!(:inactive_rma_reason) { create(:return_reason, active: false) }
-
-        let!(:accepted_return_item)            { customer_return.return_items.order('id').first.tap(&:accept!) }
-        let!(:rejected_return_item)            { customer_return.return_items.order('id').second.tap(&:reject!) }
-        let!(:manual_intervention_return_item) { customer_return.return_items.order('id').third.tap(&:require_manual_intervention!) }
-
-        subject do
-          get :edit, params: { order_id: order.to_param, id: customer_return.to_param }
-        end
-
-        it "loads the order" do
-          subject
-          expect(assigns(:order)).to eq order
-        end
-
-        it "loads the customer return" do
-          subject
-          expect(assigns(:customer_return)).to eq customer_return
-        end
-
-        it "loads the accepted return items" do
-          subject
-          expect(assigns(:accepted_return_items)).to eq [accepted_return_item]
-        end
-
-        it "loads the rejected return items" do
-          subject
-          expect(assigns(:rejected_return_items)).to eq [rejected_return_item]
-        end
-
-        it "loads the return items that require manual intervention" do
-          subject
-          expect(assigns(:manual_intervention_return_items)).to eq [manual_intervention_return_item]
-        end
-
-        it "loads the return items that are still pending" do
-          subject
-          expect(assigns(:pending_return_items)).to eq []
-        end
-
-        it "loads the reimbursements that are still pending" do
-          subject
-          expect(assigns(:pending_reimbursements)).to eq []
-        end
-
-        it "loads the correct return authorization reasons" do
-          subject
-          expect(assigns(:reasons)).to match(Spree::ReturnReason.active)
-        end
-
-        context "a return item has an inactive return authorization reason" do
-          before(:each) do
-            accepted_return_item.update(return_reason_id: inactive_rma_reason.id)
-          end
-
-          it "includes the inactive return authorization reason" do
-            subject
-            expect(assigns(:reasons)).to match(Spree::ReturnReason.active + [inactive_rma_reason])
-          end
-        end
-      end
-
-      describe "#create" do
-        let(:order) { create(:shipped_order, line_items_count: 1) }
-        let(:reception_status_event) { 'receive' }
-        let(:stock_location_id) { order.shipments.last.stock_location.id }
-        let(:customer_return_params) do
-          {
-            order_id: order.to_param,
-            customer_return: {
-              stock_location_id: stock_location_id,
-              return_items_attributes: {
-                "0" => {
-                  returned: "1",
-                  amount: "15.99",
-                  inventory_unit_id: order.inventory_units.shipped.last.id,
-                  reception_status_event: reception_status_event
-                }
-              }
-            }
-          }
-        end
-
-        subject { post :create, params: customer_return_params }
-
-        it { expect { subject }.to change { Spree::CustomerReturn.count }.by(1) }
-        it do
-          subject
-          expect(response).to redirect_to spree.edit_admin_order_customer_return_path(order, id: Spree::CustomerReturn.last.id)
-        end
-
-        it 'executes the reception status event on the return items' do
-          subject
-          customer_return = Spree::CustomerReturn.last
-          expect(customer_return.return_items.map(&:reception_status).uniq).to eq ['received']
-        end
-
-        context "missing stock location" do
-          let(:stock_location_id) { '' }
-          it { expect{ subject }.to_not change { Spree::CustomerReturn.count } }
-          it { subject; expect(response).to render_template(:new) }
-        end
-
-        context "missing reception status event" do
-          let(:reception_status_event) { '' }
-          it { expect{ subject }.to_not change { Spree::CustomerReturn.count } }
-          it { subject; expect(response).to redirect_to spree.new_admin_order_customer_return_path(order) }
-        end
-      end
-    end
-  end
-end

data/spec/controllers/spree/admin/locale_controller_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Spree::Admin::LocaleController, type: :controller do
-  stub_authorization!
-
-  before { I18n.backend.store_translations(:fr, {}) }
-
-  after do
-    I18n.locale = :en
-    I18n.reload!
-  end
-
-  context 'switch_to_locale specified' do
-    let(:json_response) { JSON.parse(response.body, symbolize_names: true) }
-
-    before do
-      get :set, params: { switch_to_locale: switch_to_locale, format: :json }
-    end
-
-    context 'available locale' do
-      let(:switch_to_locale) { 'fr' }
-
-      it 'sets locale and returns the location for the redirect' do
-        expect(I18n.locale).to eq :fr
-        expect(session[:admin_locale]).to eq(switch_to_locale)
-        expect(json_response).
-          to eq({ locale: switch_to_locale,
-                  location: spree.admin_url(host: 'test.host') })
-        expect(response).to have_http_status(:ok)
-      end
-    end
-
-    context 'unavailable locale' do
-      let(:switch_to_locale) { 'klingon' }
-
-      it 'does not change locale and returns 404' do
-        expect(I18n.locale).to eq :en
-        expect(json_response).to eq({ locale: 'en', })
-        expect(response).to have_http_status(:not_found)
-      end
-    end
-  end
-end

data/spec/controllers/spree/admin/missing_products_controller_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-# This test exists in this file because in the standard admin/products_controller spec
-# There is the stub_authorization call. This call is not triggered for this test because
-# the load_resource filter in Spree::Admin::ResourceController is prepended to the filter chain
-# this means this call is triggered before the authorize_admin call and in this case
-# the load_resource filter halts the request meaning authorize_admin is not called at all.
-describe Spree::Admin::ProductsController, type: :controller do
-  stub_authorization!
-
-  # Regression test for GH https://github.com/spree/spree/issues/538
-  it "cannot find a non-existent product" do
-    get :edit, params: { id: "non-existent-product" }
-    expect(response).to redirect_to(spree.admin_products_path)
-    expect(flash[:error]).to eql("Product is not found")
-  end
-end

data/spec/controllers/spree/admin/orders/customer_details_controller_spec.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "cancan"
-
-describe Spree::Admin::Orders::CustomerDetailsController, type: :controller do
-  context "with authorization" do
-    stub_authorization!
-
-    context '#edit' do
-      context 'when order has no shipping nor billing address' do
-        let(:order) { create(:order, number: "R123456789", ship_address: nil, bill_address: nil) }
-
-        context "with a checkout_zone set as the country of Canada" do
-          let!(:united_states) { create(:country, iso: 'US', states_required: true) }
-          let!(:canada) { create(:country, iso: 'CA', states_required: true) }
-          let!(:checkout_zone) { create(:zone, name: "Checkout Zone", countries: [canada]) }
-
-          before do
-            stub_spree_preferences(checkout_zone: checkout_zone.name)
-          end
-
-          context "and default_country_iso of the Canada" do
-            before do
-              stub_spree_preferences(default_country_iso: Spree::Country.find_by!(iso: "CA").iso)
-            end
-
-            it 'defaults the shipping address country to Canada' do
-              get :edit, params: { order_id: order.number }
-              expect(assigns(:order).shipping_address.country_id).to eq canada.id
-            end
-
-            it 'defaults the billing address country to Canada' do
-              get :edit, params: { order_id: order.number }
-              expect(assigns(:order).billing_address.country_id).to eq canada.id
-            end
-          end
-
-          context "and default_country_iso of the United States" do
-            before do
-              stub_spree_preferences(default_country_iso: Spree::Country.find_by!(iso: "US").iso)
-            end
-
-            it 'defaults the shipping address country to nil' do
-              get :edit, params: { order_id: order.number }
-              expect(assigns(:order).shipping_address.country_id).to be_nil
-            end
-
-            it 'defaults the billing address country to nil' do
-              get :edit, params: { order_id: order.number }
-              expect(assigns(:order).billing_address.country_id).to be_nil
-            end
-          end
-        end
-      end
-    end
-
-    context "#update" do
-      let(:order) { create(:order, number: "R123456789") }
-
-      before { allow(Spree::Order).to receive_message_chain(:includes, :find_by!) { order } }
-
-      it "updates + progresses the order" do
-        expect(order).to receive(:update) { true }
-        expect(order).to receive(:next) { false }
-        attributes = { order_id: order.number, order: { email: "" } }
-        put :update, params: attributes
-      end
-
-      it "does refresh the shipment rates with all shipping methods" do
-        expect(order).to receive(:refresh_shipment_rates)
-        attributes = { order_id: order.number, order: { email: "" } }
-        put :update, params: attributes
-      end
-
-      # Regression spec
-      context 'completed order' do
-        let(:order) { create(:shipped_order) }
-        let(:attributes) do
-          {
-            order_id: order.number,
-            guest_checkout: 'false',
-            user_id: order.user_id,
-            order: { email: "foo@bar.com" }
-          }
-        end
-
-        it 'allows the updating of an email address' do
-          expect { put :update, params: attributes }.to change { order.reload.email }.to eq 'foo@bar.com'
-          expect(response).to be_redirect
-        end
-      end
-
-      context "false guest checkout param" do
-        let!(:assigned_user){ create :user }
-        it "attempts to associate the user" do
-          attributes = {
-            order_id: order.number,
-            user_id: assigned_user.id,
-            guest_checkout: 'false',
-            order: { email: "" }
-          }
-
-          expect {
-            put :update, params: attributes
-          }.to change{ order.reload.user }.to(assigned_user)
-        end
-      end
-
-      context "not false guest checkout param" do
-        it "does not attempt to associate the user" do
-          allow(order).to receive_messages(update: true,
-                                           next: false,
-                                           refresh_shipment_rates: true)
-
-          attributes = {
-            order_id: order.number,
-            order: { email: "foo@example.com" }
-          }
-
-          expect {
-            put :update, params: attributes
-          }.not_to change{ order.reload.user }
-        end
-      end
-    end
-  end
-end

data/spec/controllers/spree/admin/orders_controller_spec.rb

@@ -1,408 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'cancan'
-
-describe Spree::Admin::OrdersController, type: :controller do
-  let!(:store) { create(:store) }
-  context "with authorization" do
-    stub_authorization!
-
-    before do
-      request.env["HTTP_REFERER"] = "http://localhost:3000"
-    end
-
-    let(:order) do
-      mock_model(
-        Spree::Order,
-        completed?:      true,
-        total:           100,
-        number:          'R123456789',
-        all_adjustments: adjustments,
-        ship_address: mock_model(Spree::Address)
-      )
-    end
-
-    let(:adjustments) { double('adjustments') }
-
-    before do
-      allow(Spree::Order).to receive_message_chain(:includes, find_by!: order)
-      allow(order).to receive_messages(contents: Spree::OrderContents.new(order))
-    end
-
-    context "#approve" do
-      it "approves an order" do
-        expect(order.contents).to receive(:approve).with(user: controller.try_spree_current_user)
-        put :approve, params: { id: order.number }
-        expect(flash[:success]).to eq I18n.t('spree.order_approved')
-      end
-    end
-
-    context "#cancel" do
-      it "cancels an order" do
-        expect(order).to receive(:canceled_by).with(controller.try_spree_current_user)
-        put :cancel, params: { id: order.number }
-        expect(flash[:success]).to eq I18n.t('spree.order_canceled')
-      end
-    end
-
-    context "#resume" do
-      it "resumes an order" do
-        expect(order).to receive(:resume!)
-        put :resume, params: { id: order.number }
-        expect(flash[:success]).to eq I18n.t('spree.order_resumed')
-      end
-    end
-
-    context "#resend" do
-      let(:order) { create(:completed_order_with_totals) }
-      it "resends order email" do
-        mail_message = double "Mail::Message"
-        expect(Spree::OrderMailer).to receive(:confirm_email).with(order, true).and_return mail_message
-        expect(mail_message).to receive :deliver_later
-        post :resend, params: { id: order.number }
-        expect(flash[:success]).to eq I18n.t('spree.order_email_resent')
-      end
-    end
-
-    context "pagination" do
-      it "can page through the orders" do
-        get :index, params: { page: 2, per_page: 10 }
-        expect(assigns[:orders].offset_value).to eq(10)
-        expect(assigns[:orders].limit_value).to eq(10)
-      end
-    end
-
-    # Test for https://github.com/spree/spree/issues/3346
-    context "#new" do
-      let(:user) { create(:user) }
-      before do
-        allow(controller).to receive_messages try_spree_current_user: user
-      end
-
-      it "imports a new order and sets the current user as a creator" do
-        expect(Spree::Core::Importer::Order).to receive(:import)
-          .with(nil, hash_including(created_by_id: controller.try_spree_current_user.id))
-          .and_return(order)
-        get :new
-      end
-
-      it "sets frontend_viewable to false" do
-        expect(Spree::Core::Importer::Order).to receive(:import)
-          .with(nil, hash_including(frontend_viewable: false ))
-          .and_return(order)
-        get :new
-      end
-
-      it "should associate the order with a store" do
-        expect(Spree::Core::Importer::Order).to receive(:import)
-          .with(user, hash_including(store_id: controller.current_store.id))
-          .and_return(order)
-        get :new, params: { user_id: user.id }
-      end
-
-      context "when a user_id is passed as a parameter" do
-        let(:user)  { mock_model(Spree.user_class) }
-        before { allow(Spree.user_class).to receive_messages find_by: user }
-
-        it "imports a new order and assigns the user to the order" do
-          expect(Spree::Core::Importer::Order).to receive(:import)
-            .with(user, hash_including(created_by_id: controller.try_spree_current_user.id))
-            .and_return(order)
-          get :new, params: { user_id: user.id }
-        end
-      end
-
-      it "should redirect to cart" do
-        get :new
-        expect(response).to redirect_to(spree.cart_admin_order_path(Spree::Order.last))
-      end
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/3684
-    # Rendering a form should under no circumstance mutate the order
-    context "#edit" do
-      it "does not refresh rates if the order is completed" do
-        allow(order).to receive_messages completed?: true
-        expect(order).not_to receive :refresh_shipment_rates
-        get :edit, params: { id: order.number }
-      end
-
-      it "does not refresh the rates if the order is incomplete" do
-        allow(order).to receive_messages completed?: false
-        expect(order).not_to receive :refresh_shipment_rates
-        get :edit, params: { id: order.number }
-      end
-
-      context "when order does not have a ship address" do
-        before do
-          allow(order).to receive_messages ship_address: nil
-        end
-
-        context 'when order_bill_address_used is true' do
-          before { stub_spree_preferences(order_bill_address_used: true) }
-
-          it "should redirect to the customer details page" do
-            get :edit, params: { id: order.number }
-            expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
-          end
-        end
-
-        context 'when order_bill_address_used is false' do
-          before { stub_spree_preferences(order_bill_address_used: false) }
-
-          it "should redirect to the customer details page" do
-            get :edit, params: { id: order.number }
-            expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
-          end
-        end
-      end
-    end
-
-    describe '#advance' do
-      subject do
-        put :advance, params: { id: order.number }
-      end
-
-      context 'when incomplete' do
-        before do
-          allow(order).to receive(:completed?).and_return(false, true)
-          allow(order).to receive(:next).and_return(true, false)
-        end
-
-        context 'when successful' do
-          before { allow(order).to receive(:can_complete?).and_return(true) }
-
-          it 'messages and redirects' do
-            subject
-            expect(flash[:success]).to eq I18n.t('spree.order_ready_for_confirm')
-            expect(response).to redirect_to(spree.confirm_admin_order_path(order))
-          end
-        end
-
-        context 'when unsuccessful' do
-          before do
-            allow(order).to receive(:can_complete?).and_return(false)
-            allow(order).to receive(:errors).and_return(double(full_messages: ['failed']))
-          end
-
-          it 'messages and redirects' do
-            subject
-            expect(flash[:error]).to eq order.errors.full_messages
-            expect(response).to redirect_to(spree.confirm_admin_order_path(order))
-          end
-        end
-      end
-
-      context 'when already completed' do
-        before { allow(order).to receive_messages completed?: true }
-
-        it 'messages and redirects' do
-          subject
-          expect(flash[:notice]).to eq I18n.t('spree.order_already_completed')
-          expect(response).to redirect_to(spree.edit_admin_order_path(order))
-        end
-      end
-    end
-
-    context '#confirm' do
-      subject do
-        get :confirm, params: { id: order.number }
-      end
-
-      context 'when in confirm' do
-        before { allow(order).to receive_messages completed?: false, can_complete?: true }
-
-        it 'renders the confirm page' do
-          subject
-          expect(response.status).to eq 200
-          expect(response).to render_template(:confirm)
-        end
-      end
-
-      context 'when before confirm' do
-        before { allow(order).to receive_messages completed?: false, can_complete?: false }
-
-        it 'renders the confirm_advance template (to allow refreshing of the order)' do
-          subject
-          expect(response.status).to eq 200
-          expect(response).to render_template(:confirm_advance)
-        end
-      end
-
-      context 'when already completed' do
-        before { allow(order).to receive_messages completed?: true }
-
-        it 'redirects to edit' do
-          subject
-          expect(response).to redirect_to(spree.edit_admin_order_path(order))
-        end
-      end
-    end
-
-    context "#complete" do
-      subject do
-        put :complete, params: { id: order.number }
-      end
-
-      context 'when successful' do
-        before { allow(order).to receive(:complete!) }
-
-        it 'completes the order' do
-          expect(order).to receive(:complete!)
-          subject
-        end
-
-        it 'messages and redirects' do
-          subject
-          expect(flash[:success]).to eq I18n.t('spree.order_completed')
-          expect(response).to redirect_to(spree.edit_admin_order_path(order))
-        end
-      end
-
-      context 'with an StateMachines::InvalidTransition error' do
-        let(:order) { create(:order) }
-
-        it 'messages and redirects' do
-          subject
-          expect(response).to redirect_to(spree.confirm_admin_order_path(order))
-          expect(flash[:error].to_s).to include("Cannot transition state via :complete from :cart")
-        end
-      end
-
-      context 'insufficient stock to complete the order' do
-        before do
-          expect(order).to receive(:complete!).and_raise Spree::Order::InsufficientStock
-        end
-
-        it 'messages and redirects' do
-          subject
-          expect(response).to redirect_to(spree.cart_admin_order_path(order))
-          expect(flash[:error].to_s).to eq I18n.t('spree.insufficient_stock_for_order')
-        end
-      end
-    end
-
-    # Test for https://github.com/spree/spree/issues/3919
-    context "search" do
-      let(:user) { create(:user) }
-
-      before do
-        allow(controller).to receive_messages try_spree_current_user: user
-        user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-
-        create_list(:completed_order_with_totals, 2)
-        expect(Spree::Order.count).to eq 2
-      end
-
-      context 'by line_items_variant_id_in' do
-        it "does not display duplicated results" do
-          get :index, params: { q: {
-            line_items_variant_id_in: Spree::Order.first.variants.map(&:id)
-            } }
-          expect(assigns[:orders].size).to eq 1
-        end
-      end
-
-      context 'by email' do
-        it "does not display duplicated results" do
-          get :index, params: { q: {
-            email_start: Spree::Order.first.email
-            } }
-          expect(assigns[:orders].size).to eq 1
-          expect(assigns[:orders][0].email).to eq(Spree::Order.first.email)
-        end
-      end
-    end
-
-    context "#not_finalized_adjustments" do
-      let(:order) { create(:order) }
-      let!(:finalized_adjustment) { create(:adjustment, finalized: true, adjustable: order, order: order) }
-
-      it "changes all the finalized adjustments to unfinalized" do
-        post :unfinalize_adjustments, params: { id: order.number }
-        expect(finalized_adjustment.reload.finalized).to eq(false)
-      end
-
-      it "sets the flash success message" do
-        post :unfinalize_adjustments, params: { id: order.number }
-        expect(flash[:success]).to eql('All adjustments successfully unfinalized!')
-      end
-
-      it "redirects back" do
-        post :unfinalize_adjustments, params: { id: order.number }
-        expect(response).to redirect_to(spree.admin_order_adjustments_path(order))
-      end
-    end
-
-    context "#finalize_adjustments" do
-      let(:order) { create(:order) }
-      let!(:not_finalized_adjustment) { create(:adjustment, finalized: false, adjustable: order, order: order) }
-
-      it "changes all the unfinalized adjustments to finalized" do
-        post :finalize_adjustments, params: { id: order.number }
-        expect(not_finalized_adjustment.reload.finalized).to eq(true)
-      end
-
-      it "sets the flash success message" do
-        post :finalize_adjustments, params: { id: order.number }
-        expect(flash[:success]).to eql('All adjustments successfully finalized!')
-      end
-
-      it "redirects back" do
-        post :finalize_adjustments, params: { id: order.number }
-        expect(response).to redirect_to(spree.admin_order_adjustments_path(order))
-      end
-    end
-  end
-
-  context '#authorize_admin' do
-    let!(:user) { create(:user) }
-    let!(:order) { create(:completed_order_with_totals, number: 'R987654321') }
-
-    before do
-      allow(controller).to receive_messages try_spree_current_user: user
-    end
-
-    it 'should grant access to users with an admin role' do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-      get :index
-      expect(response).to render_template :index
-    end
-
-    it 'should deny access to users without an admin role' do
-      allow(user).to receive_messages has_spree_role?: false
-      get :index
-      expect(response).to redirect_to('/unauthorized')
-    end
-
-    context 'with only permissions on Order' do
-      stub_authorization! do |_ability|
-        can [:admin, :manage], Spree::Order, number: 'R987654321'
-      end
-
-      it 'should restrict returned order(s) on index when using OrderSpecificAbility' do
-        number = order.number
-
-        3.times { create(:completed_order_with_totals) }
-        expect(Spree::Order.complete.count).to eq 4
-
-        allow(user).to receive_messages has_spree_role?: false
-        get :index
-        expect(response).to render_template :index
-        expect(assigns['orders'].size).to eq 1
-        expect(assigns['orders'].first.number).to eq number
-      end
-    end
-  end
-
-  context "order number not given" do
-    stub_authorization!
-
-    it "raise active record not found" do
-      expect {
-        get :edit, params: { id: 0 }
-      }.to raise_error ActiveRecord::RecordNotFound
-    end
-  end
-end