spree_backend 3.1.14 → 3.2.0.rc1

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

@@ -0,0 +1,46 @@
+# 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(:spree_current_user).and_return(nil)
+    end
+
+    it "redirects to root" do
+      allow(controller).to receive_message_chain(:spree, :root_path).and_return('/root')
+      get :index
+      expect(response).to redirect_to '/root'
+    end
+  end
+
+  context "#generate_api_key" do
+    let(:user) { mock_model(Spree.user_class, has_spree_role?: true) }
+
+    before do
+      allow(controller).to receive(:authorize_admin) { true }
+      allow(controller).to receive(:try_spree_current_user) { user }
+    end
+
+    it "generates the API key for a user when they visit" do
+      expect(user).to receive(:spree_api_key).and_return(nil)
+      expect(user).to receive(:generate_spree_api_key!)
+      get :index
+    end
+
+    it "does not attempt to regenerate the API key if the key is already set" do
+      expect(user).to receive(:spree_api_key).and_return('fake')
+      expect(user).not_to receive(:generate_spree_api_key!)
+      get :index
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+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
+          spree_get :index, { 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!(:rma) { create :return_authorization, order: order, return_items: [create(:return_item, inventory_unit: order.inventory_units.first)] }
+        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
+          spree_get :new, { order_id: order.to_param }
+        end
+
+        it "loads the order" do
+          subject
+          expect(assigns(:order)).to eq order
+        end
+
+        it "creates a new customer return" do
+          subject
+          expect(assigns(:customer_return)).to_not be_persisted
+        end
+
+        context "with previous customer return" do
+          let(:order) { create(:shipped_order, line_items_count: 4) }
+          let(:rma) { create(:return_authorization, order: order) }
+
+          let!(:rma_return_item) { create(:return_item, return_authorization: rma, inventory_unit: order.inventory_units.first) }
+          let!(:customer_return_return_item) { create(:return_item, return_authorization: rma, inventory_unit: order.inventory_units.last) }
+
+          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 persisted rma return items" do
+              expect(assigns(:rma_return_items).all? { |return_item| return_item.persisted? }).to eq true
+            end
+
+            it "has one rma return item" do
+              expect(assigns(:rma_return_items)).to include(rma_return_item)
+            end
+          end
+        end
+      end
+
+      describe "#edit" do
+        let(:order)           { customer_return.order }
+        let(:customer_return) { create(:customer_return, line_items_count: 3) }
+
+        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
+          spree_get :edit, { order_id: order.to_param, id: customer_return.to_param }
+        end
+
+        before do
+          subject
+        end
+
+        it "loads the order" do
+          expect(assigns(:order)).to eq order
+        end
+
+        it "loads the customer return" do
+          expect(assigns(:customer_return)).to eq customer_return
+        end
+
+        it "loads the accepted return items" do
+          expect(assigns(:accepted_return_items)).to eq [accepted_return_item]
+        end
+
+        it "loads the rejected return items" do
+          expect(assigns(:rejected_return_items)).to eq [rejected_return_item]
+        end
+
+        it "loads the return items that require manual intervention" do
+          expect(assigns(:manual_intervention_return_items)).to eq [manual_intervention_return_item]
+        end
+
+        it "loads the return items that are still pending" do
+          expect(assigns(:pending_return_items)).to eq []
+        end
+
+        it "loads the reimbursements that are still pending" do
+          expect(assigns(:pending_reimbursements)).to eq []
+        end
+      end
+
+      describe "#create" do
+        let(:order) { create(:shipped_order, line_items_count: 1) }
+        let!(:return_authorization) { create :return_authorization, order: order, return_items: [create(:return_item, inventory_unit: order.inventory_units.shipped.last)] }
+
+        subject do
+          spree_post :create, customer_return_params
+        end
+
+        context "valid customer return" do
+          let(:stock_location) { order.shipments.last.stock_location }
+
+          let!(:customer_return_params) do
+            {
+              order_id: order.to_param,
+              customer_return: {
+                stock_location_id: stock_location.id,
+                return_items_attributes: {
+                  "0" => {
+                    id: return_authorization.return_items.first.id,
+                    returned: "1",
+                    "pre_tax_amount"=>"15.99",
+                    inventory_unit_id: order.inventory_units.shipped.last.id
+                  }
+                }
+              }
+            }
+          end
+
+          it "creates a customer return" do
+            expect{ subject }.to change { Spree::CustomerReturn.count }.by(1)
+          end
+
+          it "redirects to the index page" do
+            subject
+            expect(response).to redirect_to(spree.edit_admin_order_customer_return_path(order, assigns(:customer_return)))
+          end
+        end
+
+        context "invalid customer return" do
+          let!(:customer_return_params) do
+            {
+              order_id: order.to_param,
+              customer_return: {
+                stock_location_id: "",
+                return_items_attributes: {
+                  "0" => {
+                    returned: "1",
+                    "pre_tax_amount"=>"15.99",
+                    inventory_unit_id: order.inventory_units.shipped.last.id
+                  }
+                }
+              }
+            }
+          end
+
+          it "doesn't create a customer return" do
+            expect{ subject }.to_not change { Spree::CustomerReturn.count }
+          end
+
+          it "renders the new page" do
+            subject
+            expect(response).to render_template(:new)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Spree::Admin::GeneralSettingsController, type: :controller do
+  let(:user) { create(:user) }
+
+  before do
+    allow(controller).to receive_messages spree_current_user: user
+    user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+  end
+
+  describe '#clear_cache' do
+    subject { spree_post :clear_cache }
+
+    shared_examples 'a HTTP 204 response' do
+      it 'grant access to users with an admin role' do
+        subject
+        expect(response.status).to eq(204)
+      end
+    end
+
+    context 'when no callback' do
+      it_behaves_like 'a HTTP 204 response'
+    end
+
+    context 'when callback implemented' do
+      Spree::Admin::GeneralSettingsController.class_eval do
+        custom_callback(:clear_cache).after :foo
+
+        def foo
+          # Make a call to Akamai, CloudFlare, etc invalidation....
+        end
+      end
+
+      before do
+        expect(controller).to receive(:foo).once
+      end
+
+      it_behaves_like 'a HTTP 204 response'
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+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 #538
+  it "cannot find a non-existent product" do
+    spree_get :edit, 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

@@ -0,0 +1,197 @@
+require "spec_helper"
+require "cancan"
+require "spree/testing_support/bar_ability"
+
+describe Spree::Admin::Orders::CustomerDetailsController, type: :controller do
+
+  context "with authorization" do
+    stub_authorization!
+
+    let(:order) do
+      mock_model(
+        Spree::Order,
+        total:           100,
+        number:          "R123456789",
+        billing_address: mock_model(Spree::Address)
+      )
+    end
+
+    before do
+      allow(Spree::Order).to receive_message_chain(:friendly, :find).and_return(order)
+    end
+
+    describe '#update' do
+      let(:attributes) do
+        {
+          order_id: order.number,
+          order: {
+            email: "",
+            use_billing: "",
+            bill_address_attributes: { firstname: 'john' },
+            ship_address_attributes: { firstname: 'john' }
+          },
+          guest_checkout: 'true'
+        }
+      end
+
+      def send_request(params = {})
+        spree_put :update, params
+      end
+
+      context 'using guest checkout' do
+        context 'having valid parameters' do
+          before do
+            allow(order).to receive_messages(update_attributes: true)
+            allow(order).to receive_messages(next: false)
+            allow(order).to receive_messages(complete?: true)
+            allow(order).to receive_messages(refresh_shipment_rates: true)
+          end
+
+          context 'having successful response' do
+            before { send_request(attributes) }
+            it { expect(response).to have_http_status(302) }
+            it { expect(response).to redirect_to(edit_admin_order_url(order)) }
+          end
+
+          context 'with correct method flow' do
+            it { expect(order).to receive(:update_attributes).with(ActionController::Parameters.new(attributes[:order]).permit(permitted_order_attributes)) }
+            it { expect(order).to_not receive(:next) }
+            it { expect(order).to receive(:complete?) }
+            it 'does refresh the shipment rates with all shipping methods' do
+              expect(order).to receive(:refresh_shipment_rates).
+                with(Spree::ShippingMethod::DISPLAY_ON_FRONT_AND_BACK_END)
+            end
+            it { expect(controller).to receive(:load_order).and_call_original }
+            it { expect(controller).to receive(:guest_checkout?).twice.and_call_original }
+            it { expect(controller).to_not receive(:load_user).and_call_original }
+            after { send_request(attributes) }
+          end
+        end
+
+        context 'having invalid parameters' do
+          before do
+            allow(order).to receive_messages(update_attributes: false)
+          end
+
+          context 'having failure response' do
+            before { send_request(attributes) }
+            it { expect(response).to render_template(:edit) }
+          end
+
+          context 'with correct method flow' do
+            it { expect(order).to receive(:update_attributes).with(ActionController::Parameters.new(attributes[:order]).permit(permitted_order_attributes)) }
+            it { expect(controller).to receive(:load_order).and_call_original }
+            it { expect(controller).to receive(:guest_checkout?).and_call_original }
+            it { expect(controller).to_not receive(:load_user).and_call_original }
+            after { send_request(attributes) }
+          end
+        end
+      end
+
+      context 'without using guest checkout' do
+        let(:user) { mock_model(Spree.user_class) }
+        let(:changed_attributes) { attributes.merge(guest_checkout: 'false', user_id: user.id) }
+
+        context 'having valid parameters' do
+          before do
+            allow(Spree.user_class).to receive(:find_by).and_return(user)
+            allow(order).to receive_messages(update_attributes: true)
+            allow(order).to receive_messages(next: false)
+            allow(order).to receive_messages(complete?: true)
+            allow(order).to receive_messages(refresh_shipment_rates: true)
+            allow(order).to receive_messages(associate_user!: true)
+            allow(controller).to receive(:guest_checkout?).and_return(false)
+            allow(order).to receive(:associate_user!)
+          end
+
+          context 'having successful response' do
+            before { send_request(changed_attributes) }
+            it { expect(response).to have_http_status(302) }
+            it { expect(response).to redirect_to(edit_admin_order_url(order)) }
+          end
+
+          context 'with correct method flow' do
+            it { expect(order).to receive(:update_attributes).with(ActionController::Parameters.new(attributes[:order]).permit(permitted_order_attributes)) }
+            it { expect(order).to receive(:associate_user!).with(user, order.email.blank?) }
+            it { expect(order).to_not receive(:next) }
+            it { expect(order).to receive(:complete?) }
+            it 'does refresh the shipment rates with all shipping methods' do
+              expect(order).to receive(:refresh_shipment_rates).
+                with(Spree::ShippingMethod::DISPLAY_ON_FRONT_AND_BACK_END)
+            end
+            it { expect(controller).to receive(:load_order).and_call_original }
+            it { expect(controller).to receive(:guest_checkout?).twice.and_call_original }
+            it { expect(controller).to receive(:load_user).and_call_original }
+            after { send_request(changed_attributes) }
+          end
+        end
+
+        context 'having invalid parameters' do
+          before do
+            allow(Spree.user_class).to receive(:find_by).and_return(false)
+            allow(controller).to receive(:guest_checkout?).and_return(false)
+          end
+
+          context 'having failure response' do
+            before { send_request(changed_attributes) }
+            it { expect(response).to render_template(:edit) }
+          end
+
+          context 'with correct method flow' do
+            it { expect(order).to_not receive(:update_attributes).with(ActionController::Parameters.new(attributes[:order]).permit(permitted_order_attributes)) }
+            it { expect(controller).to receive(:load_order).and_call_original }
+            it { expect(controller).to receive(:guest_checkout?).and_call_original }
+            it { expect(controller).to receive(:load_user).and_call_original }
+            after { send_request(changed_attributes) }
+          end
+        end
+
+        describe '#load_user' do
+          context 'having valid parameters' do
+            before do
+              allow(Spree.user_class).to receive(:find_by).and_return(user)
+              allow(order).to receive_messages(update_attributes: true)
+              allow(order).to receive_messages(next: false)
+              allow(order).to receive_messages(complete?: true)
+              allow(order).to receive_messages(refresh_shipment_rates: true)
+              allow(order).to receive_messages(associate_user!: true)
+              allow(controller).to receive(:guest_checkout?).and_return(false)
+              allow(order).to receive(:associate_user!)
+            end
+
+            it "expects to assign user" do
+              send_request(changed_attributes)
+              expect(assigns[:user]).to eq(user)
+            end
+
+            context 'with correct method flow' do
+              it { expect(Spree.user_class).to receive(:find_by).with(id: user.id.to_s).and_return(user) }
+              after { send_request(changed_attributes) }
+            end
+          end
+
+          context 'with invalid parameters' do
+            before do
+              allow(Spree.user_class).to receive(:find_by).and_return(nil)
+              allow(controller).to receive(:guest_checkout?).and_return(false)
+            end
+
+            it "expects to not assign user" do
+              send_request(changed_attributes)
+              expect(assigns[:user]).to_not eq(user)
+            end
+
+            context 'with correct method flow' do
+              it { expect(Spree.user_class).to receive(:find_by).with(id: user.id.to_s).and_return(nil) }
+              it "expects user class to receive find_by with email" do
+                expect(Spree.user_class).to receive(:find_by).
+                  with(email: changed_attributes[:order][:email]).and_return(nil)
+              end
+              after { send_request(changed_attributes) }
+            end
+          end
+        end
+      end
+    end
+  end
+end