solidus_backend 2.10.1 → 2.11.2

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  class GatewayWithPassword < PaymentMethod
-    preference :password, :string, default: "password"
-  end
-
-  describe Admin::PaymentMethodsController, type: :controller do
-    stub_authorization!
-
-    let(:payment_method) { GatewayWithPassword.create!(name: "Bogus", preferred_password: "haxme") }
-
-    context "GatewayWithPassword" do
-      before do
-        allow(Rails.application.config.spree).to receive(:payment_methods).and_return([GatewayWithPassword])
-      end
-
-      # regression test for https://github.com/spree/spree/issues/2094
-      it "does not clear password on update" do
-        expect(payment_method.preferred_password).to eq("haxme")
-        put :update, params: { id: payment_method.id, payment_method: { type: payment_method.class.to_s, preferred_password: "" } }
-        expect(response).to redirect_to(spree.edit_admin_payment_method_path(payment_method))
-
-        payment_method.reload
-        expect(payment_method.preferred_password).to eq("haxme")
-      end
-    end
-
-    context "tries to save invalid payment" do
-      it "doesn't break, responds nicely" do
-        post :create, params: { payment_method: { name: "", type: "Spree::PaymentMethod::BogusCreditCard" } }
-      end
-    end
-
-    it "can create a payment method of a valid type" do
-      expect {
-        post :create, params: { payment_method: { name: "Test Method", type: "Spree::PaymentMethod::BogusCreditCard" } }
-      }.to change(Spree::PaymentMethod, :count).by(1)
-
-      expect(response).to be_redirect
-      expect(response).to redirect_to spree.edit_admin_payment_method_path(assigns(:payment_method))
-    end
-
-    it "can not create a payment method of an invalid type" do
-      expect {
-        post :create, params: { payment_method: { name: "Invalid Payment Method", type: "Spree::InvalidType" } }
-      }.to change(Spree::PaymentMethod, :count).by(0)
-
-      expect(response).to be_redirect
-      expect(response).to redirect_to spree.new_admin_payment_method_path
-    end
-
-    describe "#index" do
-      subject { get :index }
-
-      let!(:first_method) { GatewayWithPassword.create! name: "First", preferred_password: "1235" }
-      let!(:second_method) { GatewayWithPassword.create! name: "Second", preferred_password: "1235" }
-
-      before do
-        second_method.move_to_top
-      end
-
-      it { is_expected.to be_successful }
-      it { is_expected.to render_template "index"  }
-
-      it "respects the order of payment methods by position" do
-        subject
-        expect(assigns(:payment_methods).to_a).to eql([second_method, first_method])
-      end
-    end
-
-    describe "#update" do
-      # Regression test for https://github.com/solidusio/solidus/issues/2789
-      let(:params) do
-        {
-          id: payment_method.id,
-          payment_method: {
-            name: 'Check',
-            type: 'Spree::PaymentMethod::Check'
-          }
-        }
-      end
-
-      it 'updates the resource' do
-        put :update, params: params
-
-        expect(response).to redirect_to(spree.edit_admin_payment_method_path(payment_method))
-        response_payment_method = Spree::PaymentMethod.find(payment_method.id)
-        expect(response_payment_method.name).to eql('Check')
-      end
-    end
-  end
-end

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

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe PaymentsController, type: :controller do
-      before do
-        allow(controller).to receive_messages try_spree_current_user: user
-      end
-
-      let(:user) { create(:admin_user) }
-      let(:order) { create(:order) }
-
-      describe '#create' do
-        context "with a valid credit card" do
-          let(:order) { create(:order_with_line_items, state: "payment") }
-          let(:payment_method) { create(:credit_card_payment_method, available_to_admin: true, available_to_users: false) }
-          let(:attributes) do
-            {
-              order_id: order.number,
-              card: "new",
-              payment: {
-                amount: order.total,
-                payment_method_id: payment_method.id.to_s,
-                source_attributes: {
-                  name: "Test User",
-                  number: "4111 1111 1111 1111",
-                  expiry: "09 / #{Time.current.year + 1}",
-                verification_value: "123"
-                }
-              }
-            }
-          end
-
-          before do
-            post :create, params: attributes
-          end
-
-          it "should process payment correctly" do
-            expect(order.payments.count).to eq(1)
-            expect(order.payments.last.state).to eq 'checkout'
-            expect(response).to redirect_to(spree.admin_order_payments_path(order))
-            expect(order.reload.state).to eq('confirm')
-          end
-
-          context 'with credit card address fields' do
-            let(:address) { build(:address) }
-
-            let(:attributes) do
-              attrs = super()
-              attrs[:payment][:source_attributes][:address_attributes] = address_attributes
-              attrs
-            end
-
-            let(:address_attributes) do
-              {
-                'firstname' => address.firstname,
-                'address1' => address.address1,
-                'city' => address.city,
-                'country_id' => address.country_id,
-                'state_id' => address.state_id,
-                'zipcode' => address.zipcode,
-                'phone' => address.phone
-              }
-            end
-
-            it 'associates the address' do
-              expect(order.payments.count).to eq(1)
-              credit_card = order.payments.last.source
-              expect(credit_card.address.attributes).to include(address_attributes)
-            end
-          end
-        end
-      end
-
-      describe '#new' do
-        # Regression test for https://github.com/spree/spree/issues/3233
-        context "with a backend payment method" do
-          context "and the payment method is active" do
-            before do
-              @payment_method = create(:check_payment_method, available_to_admin: true)
-            end
-
-            it "loads the payment method" do
-              get :new, params: { order_id: order.number }
-              expect(response.status).to eq(200)
-              expect(assigns[:payment_methods]).to include(@payment_method)
-            end
-          end
-
-          context "and the payment method is inactive" do
-            before do
-              @payment_method = create(:check_payment_method, available_to_admin: true, active: false)
-            end
-
-            it "does not load the payment method" do
-              get :new, params: { order_id: order.number }
-              expect(response.status).to eq(200)
-              expect(assigns[:payment_methods]).to be_empty
-            end
-          end
-        end
-      end
-
-      describe '#index' do
-        context "order has billing address" do
-          before do
-            order.bill_address = create(:address)
-            order.save!
-          end
-
-          context "order does not have payments" do
-            it "redirect to new payments page" do
-              get :index, params: { amount: 100, order_id: order.number }
-              expect(response).to redirect_to(spree.new_admin_order_payment_path(order))
-            end
-          end
-
-          context "order has payments" do
-            before do
-              order.payments << create(:payment, amount: order.total, order: order, state: 'completed')
-            end
-
-            it "shows the payments page" do
-              get :index, params: { amount: 100, order_id: order.number }
-              expect(response.code).to eq "200"
-            end
-          end
-        end
-
-        context "order does not have a billing address" do
-          before do
-            order.bill_address = nil
-            order.save
-          end
-
-          it "should redirect to the customer details page" do
-            get :index, params: { amount: 100, order_id: order.number }
-            expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
-          end
-        end
-      end
-
-      describe '#fire' do
-        describe 'authorization' do
-          let(:payment) { create(:payment, state: 'checkout') }
-          let(:order) { payment.order }
-
-          context 'the user is authorized' do
-            class CaptureAllowedAbility
-              include CanCan::Ability
-
-              def initialize(_user)
-                can :capture, Spree::Payment
-              end
-            end
-
-            before do
-              Spree::Ability.register_ability(CaptureAllowedAbility)
-            end
-
-            it 'allows the action' do
-              expect {
-                post(:fire, params: { id: payment.to_param, e: 'capture', order_id: order.to_param })
-              }.to change { payment.reload.state }.from('checkout').to('completed')
-            end
-
-            context 'the user is not authorized' do
-              class CaptureNotAllowedAbility
-                include CanCan::Ability
-
-                def initialize(_user)
-                  cannot :capture, Spree::Payment
-                end
-              end
-
-              before do
-                Spree::Ability.register_ability(CaptureNotAllowedAbility)
-              end
-
-              it 'does not allow the action' do
-                expect {
-                  post(:fire, params: { id: payment.to_param, e: 'capture', order_id: order.to_param })
-                }.to_not change { payment.reload.state }
-                expect(flash[:error]).to eq('Authorization Failure')
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::PricesController do
-  stub_authorization!
-
-  let!(:product) { create(:product) }
-
-  describe '#index' do
-    context "when only given a product" do
-      let(:product) { create(:product) }
-
-      subject { get :index, params: { product_id: product.slug } }
-
-      it { is_expected.to be_successful }
-
-      it 'assigns usable instance variables' do
-        subject
-        expect(assigns(:search)).to be_a(Ransack::Search)
-        expect(assigns(:variant_prices)).to eq(product.prices.for_variant)
-        expect(assigns(:master_prices)).to eq(product.prices.for_master)
-        expect(assigns(:product)).to eq(product)
-      end
-    end
-
-    context "when given a product and a variant" do
-      let(:variant) { create(:variant) }
-      let(:product) { variant.product }
-
-      subject { get :index, params: { product_id: product.slug, variant_id: variant.id } }
-
-      it { is_expected.to be_successful }
-
-      it 'assigns usable instance variables' do
-        subject
-        expect(assigns(:search)).to be_a(Ransack::Search)
-        expect(assigns(:variant_prices)).to eq(product.prices.for_variant)
-        expect(assigns(:master_prices)).to eq(product.prices.for_master)
-        expect(assigns(:variant_prices)).to include(variant.default_price)
-        expect(assigns(:product)).to eq(product)
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  module Admin
-    describe ProductPropertiesController, type: :controller do
-      stub_authorization!
-
-      describe "#index" do
-        subject { get :index, params: parameters }
-
-        context "no option values are provided" do
-          let(:product) { create(:product) }
-          let(:parameters) do
-            { product_id: product.to_param }
-          end
-
-          before { subject }
-
-          it "instantiates a new variant property rule" do
-            expect(assigns(:variant_property_rule)).to_not be_persisted
-          end
-
-          it "instantiates a new variant property rule value" do
-            expect(assigns(:variant_property_rule).values.size).to eq 1
-            expect(assigns(:variant_property_rule).values.first).to_not be_persisted
-          end
-        end
-
-        context "option values are provided" do
-          let(:size) { create(:option_type, name: 'size') }
-          let(:product) { create(:product, option_types: [size]) }
-          let(:size_small) { create(:option_value, name: 'small', option_type: size) }
-          let(:size_large) { create(:option_value, name: 'large', option_type: size) }
-          let!(:first_rule) { create(:variant_property_rule, product: product, option_value: size_small) }
-
-          context "no rules match the option values" do
-            let(:parameters) do
-              {
-                product_id: product.to_param,
-                ovi: [size_large.id]
-              }
-            end
-
-            before { subject }
-
-            it "instantiates a new variant property rule" do
-              expect(assigns(:variant_property_rule)).to_not be_persisted
-            end
-          end
-
-          context "a rule matches the option values" do
-            let(:parameters) do
-              {
-                product_id: product.to_param,
-                ovi: [size_small.id]
-              }
-            end
-
-            before { subject }
-
-            it "assigns the property rule to the only property rule that matches the option values" do
-              expect(assigns(:variant_property_rule)).to eq first_rule
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,270 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Admin::ProductsController, type: :controller do
-  stub_authorization!
-
-  context "#index" do
-    let(:ability_user) { stub_model(Spree::LegacyUser, has_spree_role?: true) }
-
-    # Regression test for https://github.com/spree/spree/issues/1259
-    it "can find a product by SKU" do
-      product = create(:product, sku: "ABC123")
-      get :index, params: { q: { sku_start: "ABC123" } }
-      expect(assigns[:collection]).not_to be_empty
-      expect(assigns[:collection]).to include(product)
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/1903
-    context 'when soft deleted products exist' do
-      let!(:soft_deleted_product) { create(:product, sku: "ABC123") }
-      before { soft_deleted_product.discard }
-
-      context 'when params[:q][:with_deleted] is not set' do
-        let(:params) { { q: {} } }
-
-        it 'filters out soft-deleted products by default' do
-          get :index, params: params
-          expect(assigns[:collection]).to_not include(soft_deleted_product)
-        end
-      end
-
-      context 'when params[:q][:with_deleted] is set to "true"' do
-        let(:params) { { q: { with_deleted: 'true' } } }
-
-        it 'includes soft-deleted products' do
-          get :index, params: params
-          expect(assigns[:collection]).to include(soft_deleted_product)
-        end
-      end
-    end
-  end
-
-  # regression test for https://github.com/spree/spree/issues/1370
-  context "adding properties to a product" do
-    let!(:product) { create(:product) }
-    specify do
-      put :update, params: { id: product.to_param, product: { product_properties_attributes: { "1" => { property_name: "Foo", value: "bar" } } } }
-      expect(flash[:success]).to eq("Product #{product.name.inspect} has been successfully updated!")
-    end
-  end
-
-  # regression test for https://github.com/solidusio/solidus/issues/2791
-  context "creating a product" do
-    before(:all) do
-      create(:shipping_category)
-    end
-
-    it "creates a product" do
-      post :create, params: {
-             product: {
-               name: "Product #1 - 9632",
-               description: "As seen on TV!",
-               price: 19.99,
-               shipping_category_id: Spree::ShippingCategory.first.id,
-             }
-           }
-      expect(flash[:success]).to eq("Product \"Product #1 - 9632\" has been successfully created!")
-    end
-
-    context "when there is a taxon" do
-      let(:first_taxon) { create(:taxon) }
-
-      it "creates a product with a taxon" do
-        post :create, params: {
-               product: {
-                 name: "Product #1 - 9632",
-                 description: "As seen on TV!",
-                 price: 19.99,
-                 shipping_category_id: Spree::ShippingCategory.first.id,
-                 taxon_ids: first_taxon.id.to_s
-               }
-             }
-        expect(flash[:success]).to eq("Product \"Product #1 - 9632\" has been successfully created!")
-      end
-
-      context "when their are multiple taxons" do
-        let(:second_taxon) { create(:taxon) }
-
-        it "creates a product with multiple taxons" do
-          post :create, params: {
-                 product: {
-                   name: "Product #1 - 9632",
-                   description: "As seen on TV!",
-                   price: 19.99,
-                   shipping_category_id: Spree::ShippingCategory.first.id,
-                   taxon_ids: "#{first_taxon.id}, #{second_taxon.id}"
-                 }
-               }
-          expect(flash[:success]).to eq("Product \"Product #1 - 9632\" has been successfully created!")
-        end
-      end
-    end
-  end
-
-  context "adding taxons to a product" do
-    let(:product) { create(:product) }
-    let(:first_taxon) { create(:taxon) }
-
-    it "adds a single taxon to a product" do
-      put :update, params: { id: product.to_param, product: { taxon_ids: first_taxon.id.to_s } }
-      expect(flash[:success]).to eq("Product #{product.name.inspect} has been successfully updated!")
-    end
-
-    context "when there are mulitple taxons" do
-      let(:second_taxon) { create(:taxon) }
-
-      it "adds multiple taxons to a product" do
-        put :update, params: { id: product.to_param, product: { taxon_ids: "#{first_taxon.id}, #{second_taxon.id}" } }
-        expect(flash[:success]).to eq("Product #{product.name.inspect} has been successfully updated!")
-      end
-    end
-  end
-
-  describe "creating variant property rules" do
-    let(:first_property) { create(:property) }
-    let(:second_property) { create(:property) }
-    let(:option_value) { create(:option_value) }
-    let!(:product) { create(:product, option_types: [option_value.option_type]) }
-    let(:payload) do
-      {
-        id: product.to_param,
-        product: {
-          id: product.id,
-          variant_property_rules_attributes: {
-            "0" => {
-              option_value_ids: option_value.id,
-              values_attributes: {
-                "0" => {
-                  property_name: first_property.name,
-                  value: "First"
-                },
-                "1" => {
-                  property_name: second_property.name,
-                  value: "Second"
-                }
-              }
-            }
-          }
-        }
-      }
-    end
-
-    subject { put :update, params: payload }
-
-    it "creates a variant property rule" do
-      expect { subject }.to change { product.variant_property_rules.count }.by(1)
-    end
-
-    it "creates a variant property rule condition" do
-      expect { subject }.to change { product.variant_property_rule_conditions.count }.by(1)
-    end
-
-    it "creates a variant property rule value for the 'First' value" do
-      subject
-      expect(product.variant_property_rule_values.find_by(value: 'First')).to_not be_nil
-    end
-
-    it "creates a variant property rule value for the 'Second' value" do
-      subject
-      expect(product.variant_property_rule_values.find_by(value: 'Second')).to_not be_nil
-    end
-
-    it "redirects to the product properties page" do
-      subject
-      expect(response).to redirect_to(spree.admin_product_product_properties_path(product, ovi: [option_value.id]))
-    end
-  end
-
-  describe "updating variant property rules" do
-    let(:first_property) { create(:property) }
-    let(:second_property) { create(:property) }
-    let(:option_value) { create(:option_value) }
-    let(:original_option_value) { create(:option_value) }
-    let!(:product) { create(:product, option_types: [option_value.option_type]) }
-    let!(:rule) do
-      create(:variant_property_rule, product: product, option_value: original_option_value)
-    end
-    let(:payload) do
-      {
-        id: product.to_param,
-        product: {
-          id: product.id,
-          variant_property_rules_attributes: {
-            "0" => {
-              id: rule.id,
-              option_value_ids: option_value.id,
-              values_attributes: {
-                "0" => {
-                  property_name: first_property.name,
-                  value: "First Edit"
-                },
-                "1" => {
-                  property_name: second_property.name,
-                  value: "Second Edit"
-                }
-              }
-            }
-          }
-        }
-      }
-    end
-
-    subject { put :update, params: payload }
-
-    it "does not create any new rules" do
-      expect { subject }.to_not change { Spree::VariantPropertyRule.count }
-    end
-
-    it "replaces the rule's condition" do
-      expect { subject }.to change { rule.reload.option_value_ids }.from([original_option_value.id]).to([option_value.id])
-    end
-
-    it "adds two values to the rule" do
-      expect { subject }.to change { rule.values.count }.by(2)
-    end
-
-    it "creates the 'First Edit' value" do
-      subject
-      expect(rule.values.find_by(value: 'First Edit')).to_not be_nil
-    end
-
-    it "creates the 'Second Edit' value" do
-      subject
-      expect(rule.values.find_by(value: 'Second Edit')).to_not be_nil
-    end
-
-    it "redirects to the product properties page" do
-      subject
-      expect(response).to redirect_to(spree.admin_product_product_properties_path(product, ovi: [option_value.id]))
-    end
-  end
-
-  context "cloning a product" do
-    let!(:product) { create(:product) }
-
-    it "duplicates the product" do
-      expect do
-        post :clone, params: { id: product.id }
-      end.to change { Spree::Product.count }.by(1)
-    end
-  end
-
-  # regression test for https://github.com/spree/spree/issues/801
-  context "destroying a product" do
-    let(:product) do
-      product = create(:product)
-      create(:variant, product: product)
-      product
-    end
-
-    it "deletes all the variants (including master) for the product" do
-      delete :destroy, params: { id: product }
-      expect(product.reload.deleted_at).not_to be_nil
-      product.variants_including_master.each do |variant|
-        expect(variant.reload.deleted_at).not_to be_nil
-      end
-    end
-  end
-end