solidus_backend_devise_token_auth 2.8.0.alpha.2

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::ReimbursementsController, type: :controller do
+  stub_authorization!
+
+  let!(:default_refund_reason) do
+    Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false)
+  end
+
+  describe '#edit' do
+    let(:reimbursement) { create(:reimbursement) }
+    let(:order) { reimbursement.order }
+    let!(:active_stock_location) { create(:stock_location, active: true) }
+    let!(:inactive_stock_location) { create(:stock_location, active: false) }
+
+    subject do
+      get :edit, params: { order_id: order.to_param, id: reimbursement.to_param }
+    end
+
+    it "loads all the active stock locations" do
+      subject
+      expect(assigns(:stock_locations)).to include(active_stock_location)
+      expect(assigns(:stock_locations)).not_to include(inactive_stock_location)
+    end
+  end
+
+  describe '#create' do
+    let(:customer_return) { create(:customer_return, line_items_count: 1) }
+    let(:order) { customer_return.order }
+    let(:return_item) { customer_return.return_items.first }
+    let(:payment) { order.payments.first }
+    before { return_item.receive! }
+
+    subject do
+      post :create, params: { order_id: order.to_param, build_from_customer_return_id: customer_return.id }
+    end
+
+    it 'creates the reimbursement' do
+      expect { subject }.to change { order.reimbursements.count }.by(1)
+      expect(assigns(:reimbursement).return_items.to_a).to eq customer_return.return_items.to_a
+    end
+
+    it 'redirects to the edit page' do
+      subject
+      expect(response).to redirect_to(spree.edit_admin_order_reimbursement_path(order, assigns(:reimbursement)))
+    end
+
+    context 'when create fails' do
+      before do
+        allow_any_instance_of(Spree::Reimbursement).to receive(:valid?) do |reimbursement, *_args|
+          reimbursement.errors.add(:base, 'something bad happened')
+          false
+        end
+      end
+
+      context 'when a referer header is present' do
+        let(:referer) { spree.edit_admin_order_customer_return_path(order, customer_return) }
+
+        it 'redirects to the referer' do
+          request.env["HTTP_REFERER"] = referer
+          expect {
+            post :create, params: { order_id: order.to_param }
+          }.to_not change { Spree::Reimbursement.count }
+          expect(response).to redirect_to(referer)
+          expect(flash[:error]).to eq("something bad happened")
+        end
+      end
+
+      context 'when a referer header is not present' do
+        it 'redirects to the admin root' do
+          expect {
+            post :create, params: { order_id: order.to_param }
+          }.to_not change { Spree::Reimbursement.count }
+          expect(response).to redirect_to(spree.admin_path)
+          expect(flash[:error]).to eq("something bad happened")
+        end
+      end
+    end
+  end
+
+  describe "#perform" do
+    let(:reimbursement) { create(:reimbursement) }
+    let(:customer_return) { reimbursement.customer_return }
+    let(:order) { reimbursement.order }
+    let(:return_items) { reimbursement.return_items }
+    let(:payment) { order.payments.first }
+
+    subject do
+      post :perform, params: { order_id: order.to_param, id: reimbursement.to_param }
+    end
+
+    it 'redirects to customer return page' do
+      subject
+      expect(response).to redirect_to spree.admin_order_reimbursement_path(order, reimbursement)
+    end
+
+    it 'performs the reimbursement' do
+      expect {
+        subject
+      }.to change { payment.refunds.count }.by(1)
+      expect(payment.refunds.last.amount).to be > 0
+      expect(payment.refunds.last.amount).to eq return_items.to_a.sum(&:total)
+    end
+
+    context "a Spree::Core::GatewayError is raised" do
+      before(:each) do
+        def controller.perform
+          raise Spree::Core::GatewayError.new('An error has occurred')
+        end
+      end
+
+      it "sets an error message with the correct text" do
+        subject
+        expect(flash[:error]).to eq 'An error has occurred'
+      end
+
+      it 'redirects to the edit page' do
+        subject
+        redirect_path = spree.edit_admin_order_reimbursement_path(order, assigns(:reimbursement))
+        expect(response).to redirect_to(redirect_path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Spree
+  module Admin
+    class WidgetsController < Spree::Admin::ResourceController
+      prepend_view_path('spec/test_views')
+
+      def model_class
+        Widget
+      end
+    end
+  end
+end
+
+describe Spree::Admin::WidgetsController, type: :controller do
+  stub_authorization!
+
+  after(:all) do
+    # Spree::Core::Engine.routes.reload_routes!
+    Rails.application.reload_routes!
+  end
+
+  with_model 'Widget', scope: :all do
+    table do |t|
+      t.string :name
+      t.integer :position
+      t.timestamps null: false
+    end
+
+    model do
+      acts_as_list
+      validates :name, presence: true
+    end
+  end
+
+  before do
+    Spree::Core::Engine.routes.draw do
+      namespace :admin do
+        resources :widgets do
+          post :update_positions, on: :member
+        end
+      end
+    end
+  end
+
+  describe '#new' do
+    subject do
+      get :new
+    end
+
+    it 'succeeds' do
+      subject
+      expect(response).to be_successful
+    end
+  end
+
+  describe '#edit' do
+    let(:widget) { Widget.create!(name: 'a widget') }
+
+    subject do
+      get :edit, params: { id: widget.to_param }
+    end
+
+    it 'succeeds' do
+      subject
+      expect(response).to be_successful
+    end
+  end
+
+  describe '#create' do
+    let(:params) do
+      { widget: { name: 'a widget' } }
+    end
+
+    subject { post :create, params: params }
+
+    it 'creates the resource' do
+      expect { subject }.to change { Widget.count }.by(1)
+    end
+
+    context 'failure' do
+      let(:params) do
+        { widget: { name: '' } } # blank name generates an error
+      end
+
+      it 'sets a flash error' do
+        subject
+        expect(flash[:error]).to eq assigns(:widget).errors.full_messages.join(', ')
+      end
+    end
+
+    context 'without any parameters' do
+      let(:params) { {} }
+
+      before do
+        allow_any_instance_of(Widget).to receive(:name).and_return('some name')
+      end
+
+      it 'creates the resource' do
+        expect { subject }.to change { Widget.count }.by(1)
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:widget) { Widget.create!(name: 'a widget') }
+
+    let(:params) do
+      {
+        id: widget.to_param,
+        widget: { name: 'widget renamed' }
+      }
+    end
+
+    subject { put :update, params: params }
+
+    it 'updates the resource' do
+      expect { subject }.to change { widget.reload.name }.from('a widget').to('widget renamed')
+    end
+
+    context 'failure' do
+      let(:params) do
+        {
+          id: widget.to_param,
+          widget: { name: '' }, # a blank name will trigger a validation error
+        }
+      end
+
+      it 'sets a flash error' do
+        subject
+        expect(flash[:error]).to eq assigns(:widget).errors.full_messages.join(', ')
+      end
+    end
+  end
+
+  describe '#destroy' do
+    let!(:widget) { Widget.create!(name: 'a widget') }
+    let(:params) { { id: widget.id } }
+
+    subject {
+      delete :destroy, params: params
+    }
+
+    it 'destroys the resource' do
+      expect { subject }.to change { Widget.count }.from(1).to(0)
+    end
+  end
+
+  describe '#update_positions' do
+    let(:widget_1) { Widget.create!(name: 'widget 1', position: 1) }
+    let(:widget_2) { Widget.create!(name: 'widget 2', position: 2) }
+
+    subject do
+      post :update_positions, params: { id: widget_1.to_param,
+        positions: { widget_1.id => '2', widget_2.id => '1' }, format: 'js' }
+    end
+
+    it 'updates the position of widget 1' do
+      expect { subject }.to change { widget_1.reload.position }.from(1).to(2)
+    end
+
+    it 'updates the position of widget 2' do
+      expect { subject }.to change { widget_2.reload.position }.from(2).to(1)
+    end
+  end
+end

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

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::ReturnAuthorizationsController, type: :controller do
+  stub_authorization!
+
+  # Regression test for https://github.com/spree/spree/issues/1370 #3
+  let!(:order) { create(:shipped_order, line_items_count: 3) }
+  let!(:return_reason) { create(:return_reason) }
+  let(:inventory_unit_1) { order.inventory_units.order('id asc')[0] }
+  let(:inventory_unit_2) { order.inventory_units.order('id asc')[1] }
+  let(:inventory_unit_3) { order.inventory_units.order('id asc')[2] }
+
+  describe '#fire' do
+    let(:return_authorization) { create(:return_authorization, order: order) }
+
+    context 'with the event parameter set' do
+      let(:params) do
+        {
+          id: return_authorization.to_param,
+          order_id: return_authorization.order.to_param,
+          e: event,
+        }
+      end
+
+      context 'when event method exists on return authorization' do
+        let(:event) { 'cancel' }
+
+        it 'sends method with ! to return authorization and redirect back' do
+          get :fire, params: params
+
+          expect(response).to redirect_to(admin_order_return_authorizations_path(order))
+          expect(flash[:success]).to eq 'Return merchandise authorization updated'
+        end
+      end
+
+      context 'when event method does not exist on return authorization' do
+        let(:event) { 'do_something_crazy' }
+
+        it 'redirects back with an error message' do
+          get :fire, params: params
+
+          expect(response).to redirect_to(admin_order_return_authorizations_path(order))
+          expect(flash[:error]).to eq 'Cannot perform this action on return merchandise authorization'
+        end
+      end
+
+      context 'when event method exists but it is not a state machine event' do
+        let(:event) { 'destroy' }
+
+        it 'redirects back with an error message' do
+          expect(return_authorization).not_to receive :destroy!
+
+          get :fire, params: params
+
+          expect(response).to redirect_to(admin_order_return_authorizations_path(order))
+          expect(flash[:error]).to eq 'Cannot perform this action on return merchandise authorization'
+        end
+      end
+    end
+  end
+
+  describe "#load_return_reasons" do
+    let!(:inactive_rma_reason) { create(:return_reason, active: false) }
+
+    context "a return item in the return authorization has an associated inactive reason" do
+      let!(:other_inactive_rma_reason) { create(:return_reason, active: false) }
+      let(:return_item) { create(:return_item, return_reason: inactive_rma_reason) }
+      let(:return_authorization) { return_item.return_authorization }
+
+      it "loads all the active rma reasons" do
+        get :edit, params: { id: return_authorization.to_param, order_id: return_authorization.order.to_param }
+        expect(assigns(:reasons)).to include(return_reason)
+        expect(assigns(:reasons)).to include(inactive_rma_reason)
+        expect(assigns(:reasons)).not_to include(other_inactive_rma_reason)
+      end
+    end
+
+    context "return authorization has an associated active reason" do
+      let(:return_authorization) { create(:return_authorization, reason: return_reason) }
+
+      it "loads all the active rma reasons" do
+        get :edit, params: { id: return_authorization.to_param, order_id: return_authorization.order.to_param }
+        expect(assigns(:reasons)).to eq [return_reason]
+      end
+    end
+
+    context "return authorization doesn't have an associated reason" do
+      it "loads all the active rma reasons" do
+        get :new, params: { order_id: order.to_param }
+        expect(assigns(:reasons)).to eq [return_reason]
+      end
+    end
+  end
+
+  describe "#load_return_items" do
+    shared_context 'without existing return items' do
+      context 'without existing return items' do
+        it 'has 3 new @form_return_items' do
+          subject
+          expect(assigns(:form_return_items).size).to eq 3
+          expect(assigns(:form_return_items).select(&:new_record?).size).to eq 3
+        end
+      end
+    end
+
+    shared_context 'with existing return items' do
+      context 'with existing return items' do
+        let!(:return_item_1) { create(:return_item, inventory_unit: inventory_unit_1, return_authorization: return_authorization) }
+
+        it 'has 1 existing return item and 2 new return items' do
+          subject
+          expect(assigns(:form_return_items).size).to eq 3
+          expect(assigns(:form_return_items).select(&:persisted?)).to eq [return_item_1]
+          expect(assigns(:form_return_items).select(&:new_record?).size).to eq 2
+        end
+      end
+    end
+
+    context '#new' do
+      subject { get :new, params: { order_id: order.to_param } }
+
+      include_context 'without existing return items'
+    end
+
+    context '#edit' do
+      subject do
+        get :edit, params: {
+          id: return_authorization.to_param,
+          order_id: order.to_param
+        }
+      end
+
+      let(:return_authorization) { create(:return_authorization, order: order) }
+
+      include_context 'without existing return items'
+      include_context 'with existing return items'
+    end
+
+    context '#create failed' do
+      subject do
+        post :create, params: {
+          return_authorization: { stock_location_id: nil }, # return authorization requires valid stock location, so this will fail
+          order_id: order.to_param
+        }
+      end
+
+      include_context 'without existing return items'
+    end
+
+    context '#update failed' do
+      subject do
+        put :update, params: {
+          return_authorization: { stock_location_id: nil }, # return authorization requires valid stock location, so this will fail
+          id: return_authorization.to_param,
+          order_id: order.to_param
+        }
+      end
+
+      let(:return_authorization) { create(:return_authorization, order: order) }
+
+      include_context 'without existing return items'
+      include_context 'with existing return items'
+    end
+  end
+
+  describe "#load_reimbursement_types" do
+    let(:order)                             { create(:order) }
+    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) }
+
+    before do
+      get :new, params: { order_id: order.to_param }
+    end
+
+    it "loads all the active reimbursement types" do
+      expect(assigns(:reimbursement_types)).to include(first_active_reimbursement_type)
+      expect(assigns(:reimbursement_types)).to include(second_active_reimbursement_type)
+      expect(assigns(:reimbursement_types)).not_to include(inactive_reimbursement_type)
+    end
+  end
+
+  describe "#load_stock_locations" do
+    let!(:active_stock_location)   { create(:stock_location, active: true) }
+    let!(:inactive_stock_location) { create(:stock_location, active: false) }
+
+    before do
+      get :new, params: { order_id: order.to_param }
+    end
+
+    it "loads all the active stock locations" do
+      expect(assigns(:stock_locations)).to include(active_stock_location)
+      expect(assigns(:stock_locations)).not_to include(inactive_stock_location)
+    end
+  end
+
+  context '#create' do
+    let(:stock_location) { create(:stock_location) }
+
+    subject { post :create, params: params }
+
+    let(:params) do
+      {
+        order_id: order.to_param,
+        return_authorization: return_authorization_params
+      }
+    end
+
+    let(:return_authorization_params) do
+      {
+        memo: "",
+        stock_location_id: stock_location.id,
+        return_reason_id: return_reason.id
+      }
+    end
+
+    it "can create a return authorization" do
+      subject
+      expect(response).to redirect_to spree.admin_order_return_authorizations_path(order)
+    end
+  end
+
+  context '#update' do
+    let(:return_authorization) { create(:return_authorization, order: order) }
+
+    let(:params) do
+      {
+        id: return_authorization.to_param,
+        order_id: order.to_param,
+        return_authorization: return_authorization_params
+      }
+    end
+    let(:return_authorization_params) do
+      {
+        memo: "",
+        return_items_attributes: return_items_params
+      }
+    end
+
+    subject { put :update, params: params }
+
+    context "adding an item" do
+      let(:return_items_params) do
+        {
+          '0' => { inventory_unit_id: inventory_unit_1.to_param }
+        }
+      end
+
+      context 'without existing items' do
+        it 'creates a new item' do
+          expect { subject }.to change { Spree::ReturnItem.count }.by(1)
+        end
+      end
+
+      context 'with existing completed items' do
+        let!(:completed_return_item) do
+          create(:return_item, {
+            return_authorization: return_authorization,
+            inventory_unit: inventory_unit_1,
+            reception_status: 'received'
+          })
+        end
+
+        it 'does not create new items' do
+          expect { subject }.to_not change { Spree::ReturnItem.count }
+          expect(assigns[:return_authorization].errors['return_items.inventory_unit']).to eq ["#{inventory_unit_1.id} has already been taken by return item #{completed_return_item.id}"]
+        end
+      end
+    end
+
+    context "removing an item" do
+      let!(:return_item) do
+        create(:return_item, return_authorization: return_authorization, inventory_unit: inventory_unit_1)
+      end
+
+      let(:return_items_params) do
+        {
+          '0' => { id: return_item.to_param, _destroy: '1' }
+        }
+      end
+
+      context 'with existing items' do
+        it 'removes the item' do
+          expect { subject }.to change { Spree::ReturnItem.count }.by(-1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::ReturnItemsController, type: :controller do
+  stub_authorization!
+
+  describe '#update' do
+    let(:customer_return) { create(:customer_return) }
+    let(:return_item) { customer_return.return_items.first }
+    let(:old_acceptance_status) { 'pending' }
+    let(:new_acceptance_status) { 'rejected' }
+
+    subject do
+      put :update, params: { id: return_item.to_param, return_item: { acceptance_status: new_acceptance_status } }
+    end
+
+    it 'updates the return item' do
+      expect {
+        subject
+      }.to change { return_item.reload.acceptance_status }.from(old_acceptance_status).to(new_acceptance_status)
+    end
+
+    it 'redirects to the customer return' do
+      subject
+      expect(response).to redirect_to spree.edit_admin_order_customer_return_path(customer_return.order, customer_return)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::RootController do
+  describe "GET index" do
+    subject { get :index }
+
+    let(:user) { build(:user) }
+    let(:ability) { Spree::Ability.new(user) }
+
+    before do
+      allow_any_instance_of(Spree::Admin::RootController).to receive(:try_spree_current_user).and_return(user)
+      allow_any_instance_of(Spree::Admin::RootController).to receive(:current_ability).and_return(ability)
+    end
+
+    context "when a user can admin and display spree orders" do
+      before do
+        ability.can :admin, Spree::Order
+        ability.can :display, Spree::Order
+      end
+
+      it { is_expected.to redirect_to(spree.admin_orders_path) }
+    end
+
+    context "when a user cannot admin and display spree orders" do
+      context "when a user can admin and home dashboards" do
+        before do
+          ability.can :admin, :dashboards
+          ability.can :home, :dashboards
+        end
+
+        it { is_expected.to redirect_to(spree.home_admin_dashboards_path) }
+      end
+
+      context "when a user cannot admin and home dashboards" do
+        # The default exception handler redirects to /unauthorized.
+        # Extensions may change this.
+        it { is_expected.to redirect_to('/unauthorized') }
+      end
+    end
+  end
+end