spree_backend 3.2.1 → 3.2.2

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

@@ -1,225 +0,0 @@
-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_index_controller_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe ReturnIndexController, type: :controller do
-      stub_authorization!
-
-      describe "#return_authorizations" do
-        let(:return_authorization) { create(:return_authorization) }
-
-        subject do
-          spree_get :return_authorizations
-        end
-
-        before { subject }
-
-        it "loads return authorizations" do
-          expect(assigns(:collection)).to include(return_authorization)
-        end
-      end
-
-      describe "#customer_returns" do
-        let(:customer_return) { create(:customer_return) }
-
-        subject do
-          spree_get :customer_returns
-        end
-
-        before { subject }
-
-        it "loads customer returns" do
-          expect(assigns(:collection)).to include(customer_return)
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-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/shipping_methods_controller_spec.rb

@@ -1,14 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

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

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe TaxCategoriesController, type: :controller do
-      stub_authorization!
-
-      describe 'GET #index' do
-        subject { spree_get :index }
-
-        it 'should be successful' do
-          expect(subject).to be_success
-        end
-      end
-
-      describe 'PUT #update' do
-        let(:tax_category) { create :tax_category }
-    
-        subject { spree_put :update, {id: tax_category.id, tax_category: { name: 'Foo', tax_code: 'Bar' }}}
-
-        it 'should redirect' do
-          expect(subject).to be_redirect
-        end
-
-        it 'should update' do
-          subject
-          tax_category.reload
-          expect(tax_category.name).to eq('Foo')
-          expect(tax_category.tax_code).to eq('Bar')
-        end
-      end
-    end
-  end
-end

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

@@ -1,161 +0,0 @@
-require 'spec_helper'
-require 'spree/testing_support/bar_ability'
-
-describe Spree::Admin::UsersController, type: :controller do
-  let(:user) { create(:user) }
-  let(:mock_user) { mock_model Spree.user_class }
-
-  before do
-    allow(controller).to receive_messages spree_current_user: user
-    user.spree_roles.clear
-    stub_const('Spree::User', user.class)
-  end
-
-  context "#show" do
-    before do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-    end
-
-    it "redirects to edit" do
-      spree_get :show, id: user.id
-      expect(response).to redirect_to spree.edit_admin_user_path(user)
-    end
-  end
-
-  context '#authorize_admin' do
-    before { use_mock_user }
-
-    it 'grant access to users with an admin role' do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-      spree_post :index
-      expect(response).to render_template :index
-    end
-
-    it "allows admins to update a user's API key" do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-      expect(mock_user).to receive(:generate_spree_api_key!).and_return(true)
-      spree_put :generate_api_key, id: mock_user.id
-      expect(response).to redirect_to(spree.edit_admin_user_path(mock_user))
-    end
-
-    it "allows admins to clear a user's API key" do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-      expect(mock_user).to receive(:clear_spree_api_key!).and_return(true)
-      spree_put :clear_api_key, id: mock_user.id
-      expect(response).to redirect_to(spree.edit_admin_user_path(mock_user))
-    end
-
-    it 'deny access to users with an bar role' do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
-      Spree::Ability.register_ability(BarAbility)
-      spree_post :index
-      expect(response).to redirect_to(spree.forbidden_path)
-    end
-
-    it 'deny access to users with an bar role' do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
-      Spree::Ability.register_ability(BarAbility)
-      spree_post :update, { id: '9' }
-      expect(response).to redirect_to(spree.forbidden_path)
-    end
-
-    it 'deny access to users without an admin role' do
-      allow(user).to receive_messages has_spree_role?: false
-      spree_post :index
-      expect(response).to redirect_to(spree.forbidden_path)
-    end
-  end
-
-  describe "#create" do
-    before do
-      use_mock_user
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-    end
-
-    it "can create a shipping_address" do
-      expect(Spree.user_class).to receive(:new).with(ActionController::Parameters.new(
-        "ship_address_attributes" => { "city" => "New York" }
-      ).permit(ship_address_attributes: permitted_address_attributes))
-      spree_post :create, user: { ship_address_attributes: { city: "New York" } }
-    end
-
-    it "can create a billing_address" do
-      expect(Spree.user_class).to receive(:new).with(ActionController::Parameters.new(
-        "bill_address_attributes" => { "city" => "New York" }
-      ).permit(bill_address_attributes: permitted_address_attributes))
-      spree_post :create, user: { bill_address_attributes: { city: "New York" } }
-    end
-  end
-
-  describe "#update" do
-    before do
-      use_mock_user
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-    end
-
-    it "allows shipping address attributes through" do
-      expect(mock_user).to receive(:update_attributes).with(ActionController::Parameters.new(
-        "ship_address_attributes" => { "city" => "New York" }
-      ).permit(ship_address_attributes: permitted_address_attributes))
-      spree_put :update, id: mock_user.id, user: { ship_address_attributes: { city: "New York" } }
-    end
-
-    it "allows billing address attributes through" do
-      expect(mock_user).to receive(:update_attributes).with(ActionController::Parameters.new(
-        "bill_address_attributes" => { "city" => "New York" }
-      ).permit(bill_address_attributes: permitted_address_attributes))
-      spree_put :update, id: mock_user.id, user: { bill_address_attributes: { city: "New York" } }
-    end
-
-    it "allows updating without password resetting" do
-      expect(mock_user).to receive(:update_attributes).with(hash_not_including(password: '', password_confirmation: ''))
-      spree_put :update, id: mock_user.id, user: { password: '', password_confirmation: '', email: 'spree@example.com' }
-    end
-  end
-
-  describe "#orders" do
-    let(:order) { create(:order) }
-    before do
-      user.orders << order
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-    end
-
-    it "assigns a list of the users orders" do
-      spree_get :orders, { id: user.id }
-      expect(assigns[:orders].count).to eq 1
-      expect(assigns[:orders].first).to eq order
-    end
-
-    it "assigns a ransack search for Spree::Order" do
-      spree_get :orders, { id: user.id }
-      expect(assigns[:search]).to be_a Ransack::Search
-      expect(assigns[:search].klass).to eq Spree::Order
-    end
-  end
-
-  describe "#items" do
-    let(:order) { create(:order) }
-    before do
-      user.orders << order
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-    end
-
-    it "assigns a list of the users orders" do
-      spree_get :items, { id: user.id }
-      expect(assigns[:orders].count).to eq 1
-      expect(assigns[:orders].first).to eq order
-    end
-
-    it "assigns a ransack search for Spree::Order" do
-      spree_get :items, { id: user.id }
-      expect(assigns[:search]).to be_a Ransack::Search
-      expect(assigns[:search].klass).to eq Spree::Order
-    end
-  end
-end
-
-def use_mock_user
-  allow(mock_user).to receive(:save).and_return(true)
-  allow(Spree.user_class).to receive(:find).with(mock_user.id.to_s).and_return(mock_user)
-  allow(Spree.user_class).to receive(:new).and_return(mock_user)
-end

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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe VariantsController, type: :controller do
-      stub_authorization!
-
-      describe "#index" do
-        let(:product) { create(:product) }
-        let!(:variant_1) { create(:variant, product: product) }
-        let!(:variant_2) { create(:variant, product: product) }
-
-        context "deleted is not requested" do
-          it "assigns the variants for a requested product" do
-            spree_get :index, product_id: product.slug
-            expect(assigns(:collection)).to include variant_1
-            expect(assigns(:collection)).to include variant_2
-          end
-        end
-
-        context "deleted is requested" do
-          before { variant_2.destroy }
-          it "assigns only deleted variants for a requested product" do
-            spree_get :index, product_id: product.slug, deleted: "on"
-            expect(assigns(:collection)).not_to include variant_1
-            expect(assigns(:collection)).to include variant_2
-          end
-        end
-      end
-    end
-  end
-end

data/spec/features/admin/configuration/analytics_tracker_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe "Analytics Tracker", type: :feature do
-  stub_authorization!
-
-  context "index" do
-    before(:each) do
-      create(:tracker)
-      create(:tracker, analytics_id: 'A200')
-      visit spree.admin_trackers_path
-    end
-
-    it "should have the right content" do
-      expect(page).to have_content("Analytics Trackers")
-    end
-
-    it "should have the right tabular values displayed" do
-      within_row(1) do
-        expect(column_text(1)).to eq("A100")
-        expect(column_text(2)).to eq("Yes")
-      end
-
-      within_row(2) do
-        expect(column_text(1)).to eq("A200")
-        expect(column_text(2)).to eq("Yes")
-      end
-    end
-   end
-
-  context "create" do
-    before(:each) do
-      visit spree.admin_trackers_path
-    end
-
-    it "should be able to create a new analytics tracker" do
-      click_link "admin_new_tracker_link"
-      fill_in "tracker_analytics_id", with: "A100"
-      click_button "Create"
-
-      expect(page).to have_content("successfully created!")
-      within_row(1) do
-        expect(column_text(1)).to eq("A100")
-        expect(column_text(2)).to eq("Yes")
-      end
-    end
-  end
-end