spree_backend 3.0.5 → 3.0.6

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

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe Spree::Admin::ReturnAuthorizationsController, :type => :controller do
+  stub_authorization!
+
+  # Regression test for #1370 #3
+  let!(:order) { create(:shipped_order, line_items_count: 3) }
+  let!(:return_authorization_reason) { create(:return_authorization_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 "#load_return_authorization_reasons" do
+    let!(:inactive_rma_reason) { create(:return_authorization_reason, active: false) }
+
+    context "return authorization has an associated inactive reason" do
+      let!(:other_inactive_rma_reason) { create(:return_authorization_reason, active: false) }
+      let(:return_authorization) { create(:return_authorization, reason: inactive_rma_reason) }
+
+      it "loads all the active rma reasons" do
+        spree_get :edit, id: return_authorization.to_param, order_id: return_authorization.order.to_param
+        expect(assigns(:reasons)).to include(return_authorization_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_authorization_reason) }
+
+      it "loads all the active rma reasons" do
+        spree_get :edit, id: return_authorization.to_param, order_id: return_authorization.order.to_param
+        expect(assigns(:reasons)).to eq [return_authorization_reason]
+      end
+    end
+
+    context "return authorization doesn't have an associated reason" do
+      it "loads all the active rma reasons" do
+        spree_get :new, order_id: order.to_param
+        expect(assigns(:reasons)).to eq [return_authorization_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 { spree_get :new, order_id: order.to_param }
+
+      include_context 'without existing return items'
+    end
+
+    context '#edit' do
+      subject do
+        spree_get :edit, {
+          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
+        spree_post :create, {
+          return_authorization: {return_authorization_reason_id: -1}, # invalid reason_id
+          order_id: order.to_param,
+        }
+      end
+
+      include_context 'without existing return items'
+    end
+
+    context '#update failed' do
+      subject do
+        spree_put :update, {
+          return_authorization: {return_authorization_reason_id: -1}, # invalid reason_id
+          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
+      spree_get :new, 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
+
+  context '#create' do
+    let(:stock_location) { create(:stock_location) }
+
+    subject { spree_post :create, 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_authorization_reason_id: return_authorization_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 { spree_put :update, 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,27 @@
+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) { 'accepted' }
+    let(:new_acceptance_status) { 'rejected' }
+
+    subject do
+      spree_put :update, 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 custome 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,35 @@
+require 'spec_helper'
+
+describe Spree::Admin::RootController do
+
+  context "unauthorized request" do
+
+    before :each do
+      allow(controller).to receive(:spree_current_user).and_return(nil)
+    end
+
+    it "redirects to orders path by default" do
+      get :index
+
+      expect(response).to redirect_to '/admin/orders'
+    end
+  end
+
+  context "authorized request" do
+    stub_authorization!
+
+    it "redirects to orders path by default" do
+      get :index
+
+      expect(response).to redirect_to '/admin/orders'
+    end
+
+    it "redirects to wherever admin_root_redirects_path tells it to" do
+      expect(controller).to receive(:admin_root_redirect_path).and_return('/grooot')
+
+      get :index
+
+      expect(response).to redirect_to '/grooot'
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Spree::Admin::SearchController, :type => :controller do
+  stub_authorization!
+  # Regression test for ernie/ransack#176
+
+  describe "users" do
+    let(:user) { create(:user, :email => "spree_commerce@example.com") }
+
+    before do
+      user.ship_address = create(:address)
+      user.bill_address = create(:address)
+      user.save
+    end
+
+    it "can find a user by their email "do
+      spree_xhr_get :users, :q => user.email
+      expect(assigns[:users]).to include(user)
+    end
+
+    it "can find a user by their ship address's first name" do
+      spree_xhr_get :users, :q => user.ship_address.firstname
+      expect(assigns[:users]).to include(user)
+    end
+
+    it "can find a user by their ship address's last name" do
+      spree_xhr_get :users, :q => user.ship_address.lastname
+      expect(assigns[:users]).to include(user)
+    end
+
+    it "can find a user by their bill address's first name" do
+      spree_xhr_get :users, :q => user.bill_address.firstname
+      expect(assigns[:users]).to include(user)
+    end
+
+    it "can find a user by their bill address's last name" do
+      spree_xhr_get :users, :q => user.bill_address.lastname
+      expect(assigns[:users]).to include(user)
+    end
+  end
+
+  describe "products" do
+    let(:product) { create(:product, :name => "Example Product") }
+
+    it "can find a product by its name "do
+      spree_xhr_get :products, :q => product.name
+      expect(assigns[:products]).to include(product)
+    end
+
+    it "can find a product by its slug "do
+      spree_xhr_get :products, :q => product.slug
+      expect(assigns[:products]).to include(product)
+    end
+  end
+
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Spree::Admin::ShippingMethodsController, :type => :controller do
+  stub_authorization!
+
+  # Regression test for #1240
+  it "should not hard-delete shipping methods" do
+    shipping_method = stub_model(Spree::ShippingMethod)
+    allow(Spree::ShippingMethod).to receive_messages :find => shipping_method
+    expect(shipping_method.deleted_at).to be_nil
+    spree_delete :destroy, :id => 1
+    expect(shipping_method.reload.deleted_at).not_to be_nil
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Spree
+  module Admin
+    describe StockItemsController, :type => :controller do
+      stub_authorization!
+
+      context "formats" do
+        let!(:stock_item) { create(:variant).stock_items.first }
+
+        it "destroy stock item via js" do
+          expect {
+            spree_delete :destroy, format: :js, id: stock_item
+          }.to change{ StockItem.count }.by(-1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Spree
+  module Admin
+    describe StockLocationsController, :type => :controller do
+      stub_authorization!
+      
+      # Regression for #4272
+      context "with no countries present" do
+        it "cannot create a new stock location" do
+          spree_get :new
+          expect(flash[:error]).to eq(Spree.t(:stock_locations_need_a_default_country))
+          expect(response).to redirect_to(spree.admin_stock_locations_path)
+        end
+      end
+
+      context "with a default country present" do
+        before do
+          country = FactoryGirl.create(:country)
+          Spree::Config[:default_country_id] = country.id
+        end
+
+        it "can create a new stock location" do
+          spree_get :new
+          expect(response).to be_success
+        end
+      end
+
+      context "with a country with the ISO code of 'US' existing" do
+        before do
+          FactoryGirl.create(:country, iso: 'US')
+        end
+
+        it "can create a new stock location" do
+          spree_get :new
+          expect(response).to be_success
+        end 
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Spree
+  describe Admin::StockTransfersController, :type => :controller do
+    stub_authorization!
+
+    let!(:stock_transfer1) {
+      StockTransfer.create do |transfer|
+        transfer.source_location_id = 1
+        transfer.destination_location_id = 2
+        transfer.reference = 'PO 666'
+      end }
+
+    let!(:stock_transfer2) {
+      StockTransfer.create do |transfer|
+        transfer.source_location_id = 3
+        transfer.destination_location_id = 4
+        transfer.reference = 'PO 666'
+      end }
+
+
+    context "#index" do
+      it "gets all transfers without search criteria" do
+        spree_get :index
+        expect(assigns[:stock_transfers].count).to eq 2
+      end
+
+      it "searches by source location" do
+        spree_get :index, :q => { :source_location_id_eq => 1 }
+        expect(assigns[:stock_transfers].count).to eq 1
+        expect(assigns[:stock_transfers]).to include(stock_transfer1)
+      end
+
+      it "searches by destination location" do
+        spree_get :index, :q => { :destination_location_id_eq => 4 }
+        expect(assigns[:stock_transfers].count).to eq 1
+        expect(assigns[:stock_transfers]).to include(stock_transfer2)
+      end
+    end
+  end
+end