solidus_backend 2.10.3 → 2.11.4

data/script/rails

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-ENGINE_ROOT = File.expand_path('..', __dir__)
-ENGINE_PATH = File.expand_path('../lib/spree/backend/engine', __dir__)
-
-require 'rails/all'
-require 'rails/engine/commands'

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# Spree's rpsec controller tests get the Spree::ControllerHacks
-# we don't need those for the anonymous controller here, so
-# we call process directly instead of get
-require 'spec_helper'
-
-describe Spree::Admin::BaseController, type: :controller do
-  controller(Spree::Admin::BaseController) do
-    def index
-      authorize! :update, Spree::Order
-      render plain: 'test'
-    end
-  end
-
-  context "unauthorized request" do
-    before do
-      allow_any_instance_of(Spree::Admin::BaseController).to receive(:try_spree_current_user).and_return(nil)
-    end
-
-    it "redirects to unauthorized" do
-      get :index
-      expect(response).to redirect_to '/unauthorized'
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::CancellationsController do
-  stub_authorization!
-
-  describe "#index" do
-    subject { get :index, params: { order_id: order.number } }
-
-    let(:order) { create(:order_ready_to_ship, line_items_count: 1) }
-
-    context "for an order with inventory" do
-      render_views
-
-      it "succeeds" do
-        expect(response).to be_ok
-      end
-    end
-  end
-
-  describe "#cancel" do
-    subject { post :short_ship, params: { order_id: order.number, inventory_unit_ids: inventory_units.map(&:id) } }
-
-    let(:order) { create(:order_with_line_items, line_items_attributes: [{ quantity: 4 }]) }
-    let(:referer) { "order_admin_page" }
-
-    context "no inventory unit ids are provided" do
-      subject { post :short_ship, params: { order_id: order.number } }
-
-      it "redirects back" do
-        subject
-        expect(response).to redirect_to(spree.admin_order_cancellations_path(order))
-      end
-
-      it "sets an error message" do
-        subject
-        expect(flash[:error]).to eq I18n.t('spree.no_inventory_selected')
-      end
-    end
-
-    context "unable to find all the inventory" do
-      let(:inventory_units) { [Spree::InventoryUnit.new(id: -1)] }
-
-      it "redirects back" do
-        subject
-        expect(response).to redirect_to(spree.admin_order_cancellations_path(order))
-      end
-
-      it "sets an error message" do
-        subject
-        expect(flash[:error]).to eq I18n.t('spree.unable_to_find_all_inventory_units')
-      end
-    end
-
-    context "successfully cancels inventory" do
-      let(:inventory_units) { order.inventory_units.not_canceled }
-
-      it "redirects to admin order edit" do
-        subject
-        expect(response).to redirect_to(spree.edit_admin_order_path(order))
-      end
-
-      it "sets an success message" do
-        subject
-        expect(flash[:success]).to eq I18n.t('spree.inventory_canceled')
-      end
-
-      it "creates a unit cancel" do
-        expect { subject }.to change { Spree::UnitCancel.count }.by(4)
-      end
-
-      it "cancels the inventory" do
-        subject
-        expect(order.reload.inventory_units.map(&:state).uniq).to match_array(['canceled'])
-      end
-
-      it "adjusts the order" do
-        expect { subject }.to change { order.reload.total }.by(-40.0)
-      end
-    end
-  end
-end

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