solidus_backend 2.9.6 → 2.11.0

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::PromotionActionsController, type: :controller do
-  stub_authorization!
-
-  let!(:promotion) { create(:promotion) }
-
-  it "can create a promotion action of a valid type" do
-    post :create, params: { promotion_id: promotion.id, action_type: "Spree::Promotion::Actions::CreateAdjustment" }
-    expect(response).to be_redirect
-    expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
-    expect(promotion.actions.count).to eq(1)
-  end
-
-  it "can not create a promotion action of an invalid type" do
-    post :create, params: { promotion_id: promotion.id, action_type: "Spree::InvalidType" }
-    expect(response).to be_redirect
-    expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
-    expect(promotion.rules.count).to eq(0)
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::PromotionCodesController do
-  stub_authorization!
-  render_views
-
-  let!(:promotion) { create(:promotion) }
-  let!(:code1) { create(:promotion_code, promotion: promotion) }
-  let!(:code2) { create(:promotion_code, promotion: promotion) }
-  let!(:code3) { create(:promotion_code, promotion: promotion) }
-
-  it "can create a CSV file with all promotion codes" do
-    get :index, params: { promotion_id: promotion.id, format: 'csv' }
-    expect(response).to be_successful
-    parsed = CSV.parse(response.body, headers: true)
-    expect(parsed.entries.map(&:to_h)).to eq([{ "Code" => code1.value }, { "Code" => code2.value }, { "Code" => code3.value }])
-  end
-
-  it "can create a new code" do
-    post :create, params: { promotion_id: promotion.id, promotion_code: { value: "new_code" } }
-    expect(response).to redirect_to(spree.admin_promotion_promotion_codes_path(promotion))
-    expect(Spree::PromotionCode.where(promotion: promotion).count).to eql(4)
-  end
-
-  it "cannot create an existing code" do
-    post :create, params: { promotion_id: promotion.id, promotion_code: { value: code1.value } }
-    expect(flash[:error]).not_to be_nil
-    expect(Spree::PromotionCode.where(promotion: promotion).count).to eql(3)
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::PromotionRulesController, type: :controller do
-  let!(:promotion) { create(:promotion) }
-
-  context "when the user is authorized" do
-    stub_authorization! do |_u|
-      Spree::PermissionSets::PromotionManagement.new(self).activate!
-    end
-
-    it "can create a promotion rule of a valid type" do
-      post :create, params: { promotion_id: promotion.id, promotion_rule: { type: "Spree::Promotion::Rules::Product" } }
-      expect(response).to be_redirect
-      expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
-      expect(promotion.rules.count).to eq(1)
-    end
-
-    it "can not create a promotion rule of an invalid type" do
-      post :create, params: { promotion_id: promotion.id, promotion_rule: { type: "Spree::InvalidType" } }
-      expect(response).to be_redirect
-      expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
-      expect(promotion.rules.count).to eq(0)
-    end
-  end
-
-  context "when the user is not authorized" do
-    it "sets an error message and redirects the user" do
-      post :create, params: { promotion_id: promotion.id, promotion_rule: { type: "Spree::Promotion::Rules::Product" } }
-
-      expect(flash[:error]).to eq("Authorization Failure")
-      expect(response).to redirect_to('/unauthorized')
-    end
-  end
-end

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

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::PromotionsController, type: :controller do
-  stub_authorization!
-
-  let!(:promotion1) { create(:promotion, name: "name1", code: "code1", path: "path1") }
-  let!(:promotion2) { create(:promotion, name: "name2", code: "code2", path: "path2") }
-  let!(:category) { create :promotion_category }
-
-  describe "#show" do
-    it "redirects to edit" do
-      expect(get(:show, params: { id: promotion1.id }))
-        .to redirect_to(action: :edit, id: promotion1.id )
-    end
-  end
-
-  describe "#index" do
-    it "succeeds" do
-      get :index
-      expect(assigns[:promotions]).to match_array [promotion2, promotion1]
-    end
-
-    it "assigns promotion categories" do
-      get :index
-      expect(assigns[:promotion_categories]).to match_array [category]
-    end
-
-    context "search" do
-      it "pages results" do
-        get :index, params: { per_page: '1' }
-        expect(assigns[:promotions]).to eq [promotion2]
-      end
-
-      it "filters by name" do
-        get :index, params: { q: { name_cont: promotion1.name } }
-        expect(assigns[:promotions]).to eq [promotion1]
-      end
-
-      it "filters by code" do
-        get :index, params: { q: { codes_value_cont: promotion1.codes.first.value } }
-        expect(assigns[:promotions]).to eq [promotion1]
-      end
-
-      it "filters by path" do
-        get :index, params: { q: { path_cont: promotion1.path } }
-        expect(assigns[:promotions]).to eq [promotion1]
-      end
-    end
-  end
-
-  describe "#create" do
-    subject { post :create, params: params }
-    let(:params) { { promotion: { name: 'some promo' } } }
-
-    context "it succeeds" do
-      context "with no single code param" do
-        it "creates a promotion" do
-          expect { subject }.to change { Spree::Promotion.count }.by(1)
-        end
-
-        it "sets the flash message" do
-          subject
-          expect(flash[:success]).to eq "Promotion has been successfully created!"
-        end
-
-        it "redirects to promotion edit" do
-          subject
-          expect(response).to redirect_to "http://test.host/admin/promotions/#{assigns(:promotion).id}/edit"
-        end
-
-        it "doesn't create any promotion codes" do
-          expect { subject }.to_not change { Spree::PromotionCode.count }
-        end
-      end
-
-      context "with a single code" do
-        let(:params) { { promotion: { name: 'some promo' }, single_code: "promo" } }
-
-        it "creates a promotion" do
-          expect { subject }.to change { Spree::Promotion.count }.by(1)
-        end
-
-        it "sets the flash message" do
-          subject
-          expect(flash[:success]).to eq "Promotion has been successfully created!"
-        end
-
-        it "redirects to promotion edit" do
-          subject
-          expect(response).to redirect_to "http://test.host/admin/promotions/#{assigns(:promotion).id}/edit"
-        end
-
-        it "creates a promotion code" do
-          expect { subject }.to change { Spree::PromotionCode.count }.by(1)
-          expect(Spree::PromotionCode.last.value).to eq("promo")
-        end
-      end
-    end
-
-    context "it fails" do
-      let(:params) { {} }
-
-      it "does not create a promotion" do
-        expect {
-          subject
-        }.not_to change { Spree::Promotion.count }
-      end
-
-      it "sets the flash error" do
-        subject
-        expect(flash[:error]).to eq "Name can't be blank"
-      end
-
-      it "renders new" do
-        subject
-        expect(response).to render_template :new
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::RefundsController do
-  stub_authorization!
-
-  describe "POST create" do
-    context "a Spree::Core::GatewayError is raised" do
-      let(:payment) { create(:payment) }
-
-      subject do
-        post :create,
-          params: {
-          refund: { amount: "50.0", refund_reason_id: "1" },
-          order_id: payment.order_id,
-          payment_id: payment.id
-        }
-      end
-
-      before(:each) do
-        def controller.create
-          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 { is_expected.to render_template(:new) }
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# 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
-
-  let(:user) { stub_model(Spree::LegacyUser, has_spree_role?: true, id: 1) }
-
-  before do
-    allow_any_instance_of(described_class).to receive(:try_spree_current_user).
-      and_return(user)
-  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 'order is recalculated' do
-      expect { subject }.to change { order.reload.payment_state }.from('paid').to('credit_owed')
-    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

@@ -1,190 +0,0 @@
-# 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
-      before_destroy :check_destroy_constraints
-
-      def check_destroy_constraints
-        return unless name == 'undestroyable'
-        errors.add :base, "You can't destroy undestroyable things!"
-        throw(:abort)
-      end
-    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
-
-    context 'failure' do
-      let(:widget) { Widget.create!(name: 'undestroyable') }
-      let(:params) { { id: widget.id } }
-
-      context 'js format' do
-        subject { delete :destroy, params: params, format: 'js' }
-
-        it 'responds with error message' do
-          subject
-          expect(response).to be_unprocessable
-          expect(response.body).to eq assigns(:widget).errors.full_messages.join(', ')
-        end
-      end
-    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