solidus_backend 2.10.1 → 2.11.2

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::ShippingMethodsController, type: :controller do
-  stub_authorization!
-
-  # Regression test for https://github.com/spree/spree/issues/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
-    delete :destroy, params: { 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,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe StockItemsController, type: :controller do
-      stub_authorization!
-
-      describe "#create" do
-        let!(:variant) { create(:variant) }
-        let!(:stock_location) { variant.stock_locations.first }
-        let(:stock_item) { variant.stock_items.first }
-        let!(:user) { create :user }
-
-        before { expect(controller).to receive(:try_spree_current_user).and_return(user) }
-        before { request.env["HTTP_REFERER"] = "product_admin_page" }
-
-        subject do
-          post :create, params: { variant_id: variant, stock_location_id: stock_location, stock_movement: { quantity: 1, stock_item_id: stock_item.id } }
-        end
-
-        it "creates a stock movement with originator" do
-          expect { subject }.to change { Spree::StockMovement.count }.by(1)
-          stock_movement = Spree::StockMovement.last
-          expect(stock_movement.originator_type).to eq "Spree::LegacyUser"
-        end
-      end
-
-      describe "#index" do
-        let!(:variant_1) { create(:variant) }
-        let!(:variant_2) { create(:variant) }
-
-        context "with product_slug param" do
-          it "scopes the variants by the product" do
-            get :index, params: { product_slug: variant_1.product.slug }
-            expect(assigns(:variants)).to include variant_1
-            expect(assigns(:variants)).not_to include variant_2
-          end
-        end
-
-        context "without product_slug params" do
-          it "allows all accessible variants to be returned" do
-            get :index
-            expect(assigns(:variants)).to include variant_1
-            expect(assigns(:variants)).to include variant_2
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe StockLocationsController, type: :controller do
-      stub_authorization!
-
-      # Regression for https://github.com/spree/spree/issues/4272
-      context "with no countries present" do
-        it "cannot create a new stock location" do
-          get :new
-          expect(flash[:error]).to eq(I18n.t('spree.stock_locations_need_a_default_country'))
-          expect(response).to redirect_to(spree.admin_stock_locations_path)
-        end
-      end
-
-      context "with a default country other than the US present" do
-        let(:country) { create :country, iso: "BR" }
-
-        before do
-          stub_spree_preferences(default_country_iso: country.iso)
-        end
-
-        it "can create a new stock location" do
-          get :new
-          expect(response).to be_successful
-        end
-      end
-
-      context "with a country with the ISO code of 'US' existing" do
-        before do
-          FactoryBot.create(:country, iso: 'US')
-        end
-
-        it "can create a new stock location" do
-          get :new
-          expect(response).to be_successful
-        end
-      end
-    end
-  end
-end

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

@@ -1,311 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-shared_examples "update reason loader" do
-  it "sets the store_credit_reasons variable to a list of categories sorted by category name " do
-    expect(assigns(:store_credit_reasons)).to eq [store_credit_reason]
-  end
-end
-
-describe Spree::Admin::StoreCreditsController do
-  stub_authorization!
-
-  let(:user) { create(:user) }
-  let(:admin_user) { create(:admin_user) }
-
-  let!(:b_credit_category) { create(:store_credit_category, name: "B category") }
-  let!(:a_credit_category) { create(:store_credit_category, name: "A category") }
-  let!(:store_credit_reason) { create(:store_credit_reason) }
-
-  describe "#show" do
-    let!(:store_credit) { create(:store_credit, user: user, category: a_credit_category) }
-    let!(:event) { create(:store_credit_auth_event, store_credit: store_credit, created_at: 5.days.ago) }
-
-    before { get :show, params: { user_id: user.id, id: store_credit.id  } }
-
-    it "sets the store_credit variable to a new store credit model" do
-      expect(assigns(:store_credit)).to eq store_credit
-    end
-
-    it "sets the store_credit_events variable to the store credit's events in chronological order" do
-      allocation_event = store_credit.store_credit_events.find_by(action: Spree::StoreCredit::ALLOCATION_ACTION)
-      expect(assigns(:store_credit_events)).to eq [event, allocation_event]
-    end
-  end
-
-  describe "#new" do
-    before { get :new, params: { user_id: create(:user).id } }
-    it { expect(assigns(:credit_categories)).to eq [a_credit_category, b_credit_category] }
-  end
-
-  describe "#create" do
-    subject { post :create, params: parameters }
-
-    before  {
-      allow(controller).to receive_messages(try_spree_current_user: admin_user)
-      create(:primary_credit_type)
-    }
-
-    context "the passed parameters are valid" do
-      let(:parameters) do
-        {
-          user_id: user.id,
-          store_credit: {
-            amount: 1.00,
-            currency: "USD",
-            category_id: a_credit_category.id
-          }
-        }
-      end
-
-      it "creates a new store credit" do
-        expect { subject }.to change(Spree::StoreCredit, :count).by(1)
-      end
-
-      it "associates the store credit with the user" do
-        subject
-        expect(user.reload.store_credits.count).to eq 1
-      end
-
-      it "assigns the store credit's created by to the current user" do
-        subject
-        expect(user.reload.store_credits.first.created_by).to eq admin_user
-      end
-
-      it 'sets the admin as the store credit event originator' do
-        expect { subject }.to change { Spree::StoreCreditEvent.count }.by(1)
-        expect(Spree::StoreCreditEvent.last.originator).to eq admin_user
-      end
-    end
-
-    context "the passed parameters are invalid" do
-      let(:parameters) do
-        {
-          user_id: user.id,
-          store_credit: {
-            amount: -1.00,
-            category_id: a_credit_category.id
-          }
-        }
-      end
-
-      it { expect { subject }.not_to change(Spree::StoreCredit, :count) }
-    end
-  end
-
-  describe "#edit_amount" do
-    let!(:store_credit) { create(:store_credit, user: user, category: a_credit_category) }
-
-    before { get :edit_amount, params: { user_id: user.id, id: store_credit.id } }
-
-    it_behaves_like "update reason loader"
-
-    it "sets the store_credit variable to the persisted store credit" do
-      expect(assigns(:store_credit)).to eq store_credit
-    end
-  end
-
-  describe "#edit_validity" do
-    let!(:store_credit) { create(:store_credit, user: user, category: a_credit_category) }
-
-    before { get :edit_validity, params: { user_id: user.id, id: store_credit.id } }
-
-    it_behaves_like "update reason loader"
-
-    it "sets the store_credit variable to the persisted store credit" do
-      expect(assigns(:store_credit)).to eq store_credit
-    end
-  end
-
-  describe "#update" do
-    let(:memo)          { "New memo" }
-    let!(:store_credit) { create(:store_credit, user: user) }
-
-    subject { put :update, params: parameters.merge(format: :json) }
-
-    before  { allow(controller).to receive_messages(try_spree_current_user: admin_user) }
-
-    context "the passed parameters are valid" do
-      let(:parameters) do
-        {
-          user_id: user.id,
-          id: store_credit.id,
-          store_credit: {
-            memo: memo
-          }
-        }
-      end
-
-      it "updates the memo to be the passed in value" do
-        expect { subject }.to change { store_credit.reload.memo }.to(memo)
-      end
-
-      it "returns a success message" do
-        subject
-        expect(response).to have_http_status(:ok)
-        expect(JSON.parse(response.body)['message']).to match("Store Credit has been successfully updated!")
-      end
-    end
-
-    context "the passed parameters are invalid" do
-      let(:parameters) do
-        {
-          user_id: user.id,
-          id: store_credit.id,
-          store_credit: {
-            category_id: b_credit_category.id
-          }
-        }
-      end
-      it "doesn't update the store credit's category" do
-        expect { subject }.to_not change { store_credit.reload.category }
-      end
-
-      it "returns an error message" do
-        subject
-        expect(response).to have_http_status(:bad_request)
-        expect(JSON.parse(response.body)['message']).to match("Unable to update store credit")
-      end
-    end
-  end
-
-  describe "#update_amount" do
-    let(:original_amount) { 100.0 }
-    let!(:store_credit)   { create(:store_credit, user: user, amount: original_amount) }
-    let!(:store_credit_reason) { create(:store_credit_reason) }
-    let(:parameters) do
-      {
-        user_id: user.id,
-        id: store_credit.id,
-        store_credit_reason_id: store_credit_reason.id,
-        store_credit: {
-          amount: updated_amount
-        }
-      }
-    end
-
-    subject { put :update_amount, params: parameters }
-
-    before  { allow(controller).to receive_messages(try_spree_current_user: admin_user) }
-
-    context "the passed parameters are valid" do
-      let(:updated_amount) { 300.0 }
-
-      context "the store credit has been partially used" do
-        before { store_credit.update(amount_used: 10.0) }
-
-        context "the new amount is greater than the used amount" do
-          let(:updated_amount) { 11.0 }
-
-          before { subject }
-
-          it "updates the amount to be the passed in amount" do
-            expect(store_credit.reload.amount).to eq updated_amount
-          end
-        end
-
-        context "the new amount is less than the used amount" do
-          let(:updated_amount) { 9.0 }
-
-          before { subject }
-
-          it "does not update the amount" do
-            expect(store_credit.reload.amount).to eq original_amount
-          end
-
-          it "renders the edit_amount template" do
-            expect(response).to render_template :edit_amount
-          end
-
-          it "adds an error message to the flash" do
-            expect(flash.now[:error]).to match "Unable to update"
-          end
-
-          it_behaves_like "update reason loader"
-        end
-      end
-
-      context "the store credit has not been used" do
-        it "sets a success message in the flash" do
-          subject
-          expect(flash.now[:success]).to match "Store Credit has been successfully updated!"
-        end
-
-        it "does not create a new store credit" do
-          expect { subject }.to_not change(Spree::StoreCredit, :count)
-        end
-
-        it "updates passed amount" do
-          subject
-          expect(store_credit.reload.amount).to eq updated_amount
-        end
-      end
-    end
-
-    context "the passed parameters are invalid" do
-      let(:updated_amount) { -1.00 }
-
-      before { subject }
-
-      it "does not update the amount" do
-        expect(store_credit.reload.amount).to eq original_amount
-      end
-
-      it "renders the edit_amount template" do
-        expect(response).to render_template :edit_amount
-      end
-
-      it "adds an error message to the flash" do
-        expect(flash.now[:error]).to match "Unable to update"
-      end
-
-      it_behaves_like "update reason loader"
-    end
-  end
-
-  describe "#invalidate" do
-    let!(:store_credit) { create(:store_credit, user: user, category: b_credit_category) }
-
-    let(:parameters) do
-      {
-        user_id: user.id,
-        id: store_credit.id,
-        store_credit_reason_id: store_credit_reason.id
-      }
-    end
-
-    subject { put :invalidate, params: parameters }
-
-    it "attempts to invalidate the store credit" do
-      expect { subject }.to change { store_credit.reload.invalidated_at }.from(nil)
-    end
-
-    context "the invalidation is unsuccessful" do
-      before do
-        store_credit.authorize(5.0, "USD")
-        subject
-      end
-
-      it "doesn't invalidate the store credit" do
-        expect(store_credit.reload.invalidated_at).to be_nil
-      end
-
-      it "renders the edit_validity template" do
-        expect(response).to render_template :edit_validity
-      end
-
-      it "sets an error message in the flash" do
-        expect(flash.now[:error]).to match "Unable to invalidate store credit"
-      end
-
-      it_behaves_like "update reason loader"
-    end
-
-    context "the invalidation is successful" do
-      it "redirects to index" do
-        expect(subject).to redirect_to spree.admin_user_store_credit_path(user, store_credit)
-      end
-    end
-  end
-end

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

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::UsersController, type: :controller do
-  let(:user) { create(:user) }
-
-  let(:state) { create(:state, state_code: 'NY') }
-  let(:valid_address_attributes) do
-    {
-      firstname: 'Foo',
-      lastname: 'Bar',
-      city: "New York",
-      country_id: state.country.id,
-      state_id: state.id,
-      phone: '555-555-5555',
-      address1: '123 Fake St.',
-      zipcode: '10001',
-    }
-  end
-
-  context "#show" do
-    stub_authorization! do |_user|
-      can [:admin, :manage], Spree.user_class
-    end
-
-    it "redirects to edit" do
-      get :show, params: { id: user.id }
-      expect(response).to redirect_to spree.edit_admin_user_path(user)
-    end
-  end
-
-  context '#authorize_admin' do
-    context "with ability to admin users" do
-      stub_authorization! do |_user|
-        can [:manage], Spree.user_class
-      end
-
-      it 'can visit index' do
-        post :index
-        expect(response).to be_successful
-      end
-
-      it "allows admins to update a user's API key" do
-        expect {
-          put :generate_api_key, params: { id: user.id }
-        }.to change { user.reload.spree_api_key }
-        expect(response).to redirect_to(spree.edit_admin_user_path(user))
-      end
-
-      it "allows admins to clear a user's API key" do
-        user.generate_spree_api_key!
-        expect {
-          put :clear_api_key, params: { id: user.id }
-        }.to change{ user.reload.spree_api_key }.to(nil)
-        expect(response).to redirect_to(spree.edit_admin_user_path(user))
-      end
-    end
-
-    context "without ability to admin users" do
-      stub_authorization! do |_user|
-      end
-
-      it 'denies access' do
-        post :index
-        expect(response).to redirect_to '/unauthorized'
-      end
-    end
-  end
-
-  describe "#create" do
-    let(:dummy_role) { Spree::Role.create(name: "dummyrole") }
-
-    # The created user
-    def user
-      Spree.user_class.last
-    end
-
-    stub_authorization! do |_user|
-      can :manage, Spree.user_class
-    end
-
-    context "when the user can manage roles" do
-      stub_authorization! do |_user|
-        can :manage, Spree.user_class
-        can :manage, Spree::Role
-      end
-
-      it "can create user with roles" do
-        post :create, params: { user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
-        expect(user.spree_roles).to eq([dummy_role])
-      end
-
-      it "can create user without roles" do
-        post :create, params: { user: { first_name: "Bob" } }
-        expect(user.spree_roles).to eq([])
-      end
-    end
-
-    context "when the user cannot manage roles" do
-      it "cannot assign users roles" do
-        post :create, params: { user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
-        expect(user.spree_roles).to eq([])
-      end
-
-      it "can create user without roles" do
-        post :create, params: { user: { first_name: "Bob" } }
-        expect(user.spree_roles).to eq([])
-      end
-    end
-
-    it "can create a shipping_address" do
-      post :create, params: { user: { ship_address_attributes: valid_address_attributes } }
-      expect(user.reload.ship_address.city).to eq('New York')
-    end
-
-    it "can create a billing_address" do
-      post :create, params: { user: { bill_address_attributes: valid_address_attributes } }
-      expect(user.reload.bill_address.city).to eq('New York')
-    end
-
-    it "can set stock locations" do
-      location = Spree::StockLocation.create(name: "my_location")
-      location_2 = Spree::StockLocation.create(name: "my_location_2")
-      post :create, params: { user: { stock_location_ids: [location.id, location_2.id] } }
-      expect(user.stock_locations).to match_array([location, location_2])
-    end
-  end
-
-  describe "#update" do
-    let(:dummy_role) { Spree::Role.create(name: "dummyrole") }
-    let(:ability) { Spree::Ability.new(user) }
-
-    stub_authorization! do |_user|
-      can :manage, Spree.user_class
-    end
-
-    context "when the user can manage roles" do
-      stub_authorization! do |_user|
-        can :manage, Spree.user_class
-        can :manage, Spree::Role
-      end
-
-      it "can set roles" do
-        expect {
-          put :update, params: { id: user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
-        }.to change { user.reload.spree_roles.to_a }.to([dummy_role])
-      end
-
-      it "can clear roles" do
-        user.spree_roles << dummy_role
-        expect {
-          put :update, params: { id: user.id, user: { first_name: "Bob", spree_role_ids: [""] } }
-        }.to change { user.reload.spree_roles.to_a }.to([])
-      end
-
-      context 'when no role params are present' do
-        it 'does not clear all present user roles' do
-          user.spree_roles << dummy_role
-          put :update, params: { id: user.id, user: { first_name: "Bob" } }
-          expect(user.reload.spree_roles).to_not be_empty
-        end
-      end
-    end
-
-    context "when the user cannot manage roles" do
-      it "cannot set roles" do
-        expect {
-          put :update, params: { id: user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
-        }.not_to change { user.reload.spree_roles.to_a }
-      end
-
-      it "cannot clear roles" do
-        user.spree_roles << dummy_role
-        expect {
-          put :update, params: { id: user.id, user: { first_name: "Bob" } }
-        }.not_to change { user.reload.spree_roles.to_a }
-      end
-    end
-
-    context "allowed to update email" do
-      stub_authorization! do |_user|
-        can [:admin, :update, :update_email], Spree.user_class
-      end
-
-      it "can change email of a user" do
-        expect {
-          put :update, params: { id: user.id, user: { email: "bob@example.com" } }
-        }.to change { user.reload.email }.to("bob@example.com")
-      end
-    end
-
-    context "not allowed to update email" do
-      stub_authorization! do |_user|
-        can [:admin, :update], Spree.user_class
-      end
-
-      it "cannot change email of a user" do
-        expect {
-          put :update, params: { id: user.id, user: { email: "bob@example.com" } }
-        }.not_to change { user.reload.email }
-      end
-    end
-
-    context "allowed to update passwords" do
-      it "can change password of a user" do
-        expect {
-          put :update, params: { id: user.id, user: { password: "diff123", password_confirmation: "diff123" } }
-        }.to_not raise_error
-      end
-    end
-
-    context "not allowed to update passwords" do
-      stub_authorization! do |_user|
-        can [:admin, :update], Spree.user_class
-      end
-
-      it "cannot change password of a user" do
-        allow(ActionController::Parameters).
-          to receive(:action_on_unpermitted_parameters).and_return(:raise)
-
-        expect {
-          put :update, params: { id: user.id, user: { password: "diff123", password_confirmation: "diff123" } }
-        }.to raise_error(ActionController::UnpermittedParameters)
-      end
-    end
-
-    it "can update ship_address attributes" do
-      post :update, params: { id: user.id, user: { ship_address_attributes: valid_address_attributes } }
-      expect(user.reload.ship_address.city).to eq('New York')
-    end
-
-    it "can update bill_address attributes" do
-      post :update, params: { id: user.id, user: { bill_address_attributes: valid_address_attributes } }
-      expect(user.reload.bill_address.city).to eq('New York')
-    end
-
-    it "can set stock locations" do
-      location = Spree::StockLocation.create(name: "my_location")
-      location_2 = Spree::StockLocation.create(name: "my_location_2")
-      post :update, params: { id: user.id, user: { stock_location_ids: [location.id, location_2.id] } }
-      expect(user.stock_locations).to match_array([location, location_2])
-    end
-  end
-
-  describe "#orders" do
-    stub_authorization! do |_user|
-      can :manage, Spree.user_class
-    end
-
-    let(:order) { create(:order) }
-    before { user.orders << order }
-
-    it "assigns a list of the users orders" do
-      get :orders, params: { 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
-      get :orders, params: { id: user.id }
-      expect(assigns[:search]).to be_a Ransack::Search
-      expect(assigns[:search].klass).to eq Spree::Order
-    end
-  end
-
-  describe "#items" do
-    stub_authorization! do |_user|
-      can :manage, Spree.user_class
-    end
-
-    let(:order) { create(:order) }
-    before { user.orders << order }
-
-    it "assigns a list of the users orders" do
-      get :items, params: { 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
-      get :items, params: { id: user.id }
-      expect(assigns[:search]).to be_a Ransack::Search
-      expect(assigns[:search].klass).to eq Spree::Order
-    end
-  end
-end