solidus_core 2.10.0 → 2.11.0

data/spec/lib/spree/core/controller_helpers/order_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Order
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Order, type: :controller do
-  controller(FakesController) {}
-
-  let(:user) { create(:user) }
-  let(:order) { create(:order, user: user, store: store) }
-  let(:store) { create(:store) }
-
-  before do
-    allow(controller).to receive_messages(current_store: store)
-    allow(controller).to receive_messages(current_pricing_options: Spree::Config.pricing_options_class.new(currency: Spree::Config.currency))
-    allow(controller).to receive_messages(try_spree_current_user: user)
-  end
-
-  describe '#simple_current_order' do
-    it "returns an empty order" do
-      Spree::Deprecation.silence do
-        expect(controller.simple_current_order.item_count).to eq 0
-      end
-    end
-    it 'returns Spree::Order instance' do
-      Spree::Deprecation.silence do
-        allow(controller).to receive_messages(cookies: double(signed: { guest_token: order.guest_token }))
-        expect(controller.simple_current_order).to eq order
-      end
-    end
-    it 'assigns the current_store id' do
-      Spree::Deprecation.silence do
-        expect(controller.simple_current_order.store_id).to eq store.id
-      end
-    end
-    it 'is deprecated' do
-      Spree::Deprecation.silence do
-        expect(Spree::Deprecation).to(receive(:warn))
-        controller.simple_current_order
-      end
-    end
-  end
-
-  describe '#current_order' do
-    context 'create_order_if_necessary option is false' do
-      let!(:order) { create :order, user: user, store: store }
-      it 'returns current order' do
-        expect(controller.current_order).to eq order
-      end
-    end
-
-    context 'create_order_if_necessary option is true' do
-      subject { controller.current_order(create_order_if_necessary: true) }
-
-      it 'creates new order' do
-        expect {
-          subject
-        }.to change(Spree::Order, :count).from(0).to(1)
-      end
-
-      it 'assigns the current_store id' do
-        subject
-        expect(Spree::Order.last.store_id).to eq store.id
-      end
-
-      it 'records last_ip_address' do
-        expect {
-          subject
-        }.to change {
-          Spree::Order.last.try!(:last_ip_address)
-        }.from(nil).to("0.0.0.0")
-      end
-    end
-  end
-
-  describe '#associate_user' do
-    before { allow(controller).to receive_messages(current_order: order) }
-    context "user's email is blank" do
-      let(:user) { create(:user, email: '') }
-      it 'calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-    context "user isn't blank" do
-      it 'does not calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).not_to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-  end
-
-  describe '#set_current_order' do
-    let(:incomplete_order) { create(:order, store: incomplete_order_store, user: user) }
-
-    context 'when current order not equal to users incomplete orders' do
-      before { allow(controller).to receive_messages(current_order: order, last_incomplete_order: incomplete_order, cookies: double(signed: { guest_token: 'guest_token' })) }
-
-      context "an order from another store" do
-        let(:incomplete_order_store) { create(:store) }
-
-        it 'doesnt call Spree::Order#merge! method' do
-          expect(order).to_not receive(:merge!)
-          controller.set_current_order
-        end
-      end
-      context "an order from the same store" do
-        let(:incomplete_order_store) { store }
-
-        it 'calls Spree::Order#merge! method' do
-          expect(order).to receive(:merge!).with(incomplete_order, user)
-          controller.set_current_order
-        end
-      end
-    end
-  end
-
-  describe '#ip_address' do
-    it 'returns remote ip' do
-      expect(controller.ip_address).to eq request.remote_ip
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/payment_parameters_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
-  controller(ApplicationController) do
-    include Spree::Core::ControllerHelpers::PaymentParameters
-  end
-
-  let(:params_hash) { subject.permit!.to_h.deep_symbolize_keys }
-
-  shared_examples "unpermitted params" do
-    it "is unpermitted ActionController::Parameters" do
-      expect(subject).to be_a(ActionController::Parameters)
-      expect(subject).not_to be_permitted
-    end
-  end
-
-  shared_examples "unchanged params" do
-    let!(:original_param_hash) { params.dup.permit!.to_h.deep_symbolize_keys }
-
-    it 'returns the original hash' do
-      expect(params_hash).to eq(original_param_hash)
-    end
-
-    it_behaves_like "unpermitted params"
-  end
-
-  describe '#move_payment_source_into_payments_attributes' do
-    subject do
-      controller.move_payment_source_into_payments_attributes(params)
-    end
-
-    let(:params) do
-      ActionController::Parameters.new(
-        payment_source: {
-          payment_method_1.id.to_s => credit_card_1_params,
-          payment_method_2.id.to_s => credit_card_2_params
-        },
-        order: {
-          payments_attributes: [
-            {
-              payment_method_id: payment_method_1.id.to_s
-            }
-          ],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-
-    let(:payment_method_1) { create(:credit_card_payment_method) }
-    let(:payment_method_2) { create(:credit_card_payment_method) }
-    let(:credit_card_1_params) { attributes_for(:credit_card, name: 'Jordan1') }
-    let(:credit_card_2_params) { attributes_for(:credit_card, name: 'Jordan2') }
-
-    it 'produces the expected hash' do
-      expect(params_hash).to eq(
-        order: {
-          payments_attributes: [
-            {
-              payment_method_id: payment_method_1.id.to_s,
-              source_attributes: credit_card_1_params
-            }
-          ],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-
-    it_behaves_like "unpermitted params"
-
-    context 'when payment_source is missing' do
-      before { params.delete(:payment_source) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when order params are missing' do
-      before { params.delete(:order) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when payment_attributes are missing' do
-      before { params[:order].delete(:payments_attributes) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when the payment_method_id is missing' do
-      before { params[:order][:payments_attributes][0].delete(:payment_method_id) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when the payment_method_id does not match a payments source' do
-      before { params[:order][:payments_attributes][0][:payment_method_id] = -1 }
-      it_behaves_like "unchanged params"
-    end
-  end
-
-  describe '#move_existing_card_into_payments_attributes' do
-    subject do
-      controller.move_existing_card_into_payments_attributes(params)
-    end
-
-    let(:params) do
-      ActionController::Parameters.new(
-        order: {
-          existing_card: '123',
-          other_order_param: 1
-        },
-        cvc_confirm: '456',
-        other_param: 2
-      )
-    end
-
-    it 'produces the expected hash' do
-      expect(params_hash).to eq(
-        order: {
-          payments_attributes: [
-            {
-              source_attributes: {
-                existing_card_id: '123',
-                verification_value: '456'
-              }
-            }
-          ],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-
-    it_behaves_like "unpermitted params"
-
-    context 'when cvc_confirm is missing' do
-      before { params.delete(:cvc_confirm) }
-
-      it 'produces the expected hash' do
-        expect(params_hash).to eq(
-          order: {
-            payments_attributes: [
-              {
-                source_attributes: {
-                  existing_card_id: '123',
-                  verification_value: nil
-                }
-              }
-            ],
-            other_order_param: 1
-          },
-          other_param: 2
-        )
-      end
-
-      it_behaves_like "unpermitted params"
-    end
-
-    context 'when order params are missing' do
-      before { params.delete(:order) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when existing_card is missing' do
-      before { params[:order].delete(:existing_card) }
-      it_behaves_like "unchanged params"
-    end
-  end
-
-  describe '#set_payment_parameters_amount' do
-    subject do
-      controller.set_payment_parameters_amount(params, order)
-    end
-
-    let(:params) do
-      ActionController::Parameters.new(
-        order: {
-          payments_attributes: [{}],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-    let(:order) { create(:order_with_line_items, line_items_price: 101.00, line_items_count: 1, shipment_cost: 0) }
-
-    it 'produces the expected hash' do
-      expect(params_hash).to eq(
-        order: {
-          payments_attributes: [{ amount: 101 }],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/pricing_spec.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Pricing
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Pricing, type: :controller do
-  controller(FakesController) {}
-
-  before do
-    allow(controller).to receive(:current_store).and_return(store)
-  end
-
-  describe '#current_currency' do
-    subject { controller.current_currency }
-
-    context "when store default_currency is nil" do
-      let(:store) { nil }
-      it { Spree::Deprecation.silence { is_expected.to eq('USD') } }
-    end
-
-    context "when the current store default_currency empty" do
-      let(:store) { FactoryBot.create :store, default_currency: '' }
-
-      it { Spree::Deprecation.silence { is_expected.to eq('USD') } }
-    end
-
-    context "when the current store default_currency is a currency" do
-      let(:store) { FactoryBot.create :store, default_currency: 'EUR' }
-
-      it { Spree::Deprecation.silence { is_expected.to eq('EUR') } }
-    end
-  end
-
-  describe '#current_pricing_options' do
-    subject { controller.current_pricing_options }
-
-    let(:store) { FactoryBot.create(:store, default_currency: nil) }
-
-    it { is_expected.to be_a(Spree::Config.pricing_options_class) }
-
-    context "currency" do
-      subject { controller.current_pricing_options.currency }
-
-      context "when store default_currency is nil" do
-        let(:store) { nil }
-        it { is_expected.to eq('USD') }
-      end
-
-      context "when the current store default_currency empty" do
-        let(:store) { FactoryBot.create :store, default_currency: '' }
-
-        it { is_expected.to eq('USD') }
-      end
-
-      context "when the current store default_currency is a currency" do
-        let(:store) { FactoryBot.create :store, default_currency: 'EUR' }
-
-        it { is_expected.to eq('EUR') }
-      end
-    end
-
-    context "country_iso" do
-      subject { controller.current_pricing_options.country_iso }
-
-      let(:store) { FactoryBot.create(:store, cart_tax_country_iso: cart_tax_country_iso) }
-
-      context "when the store has a cart tax country set" do
-        let(:cart_tax_country_iso) { "DE" }
-        it { is_expected.to eq("DE") }
-      end
-
-      context "when the store has no cart tax country set" do
-        let(:cart_tax_country_iso) { nil }
-        it { is_expected.to be_nil }
-      end
-    end
-
-    context "from context" do
-      subject { controller.current_pricing_options }
-
-      let(:store) { FactoryBot.create :store, default_currency: 'USD' }
-
-      context "when the whole context is passed" do
-        it "receives the right object " do
-          expect(Spree::Config.pricing_options_class).to receive(:from_context).with(controller)
-          is_expected.to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/search_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Search
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Search, type: :controller do
-  controller(FakesController) {}
-
-  describe '#build_searcher' do
-    it 'returns Spree::Core::Search::Base instance' do
-      allow(controller).to receive_messages(
-        try_spree_current_user: create(:user),
-        current_pricing_options: Spree::Config.pricing_options_class.new(currency: 'USD')
-      )
-      expect(controller.build_searcher({}).class).to eq Spree::Core::Search::Base
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/store_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Store
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Store, type: :controller do
-  controller(FakesController) {}
-
-  describe '#current_store' do
-    let!(:store) { create :store, default: true }
-    it 'returns current store' do
-      expect(controller.current_store).to eq store
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/strong_parameters_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::StrongParameters
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::StrongParameters, type: :controller do
-  controller(FakesController) {}
-
-  describe '#permitted_attributes' do
-    it 'returns Spree::PermittedAttributes module' do
-      expect(controller.permitted_attributes).to eq Spree::PermittedAttributes
-    end
-  end
-
-  describe '#permitted_payment_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_payment_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_checkout_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_checkout_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_order_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_order_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_product_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_product_attributes.class).to eq Array
-    end
-  end
-end

data/spec/lib/spree/core/current_store_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Core::CurrentStore do
-  describe "#store" do
-    subject { Spree::Deprecation.silence { Spree::Core::CurrentStore.new(request).store } }
-
-    context "with a default" do
-      let(:request) { double(headers: {}, env: {}) }
-      let!(:store_1) { create :store, default: true }
-
-      it "returns the default store" do
-        expect(subject).to eq(store_1)
-      end
-
-      context "with a domain match" do
-        let(:request) { double(headers: {}, env: { "SERVER_NAME" => url } ) }
-        let(:url) { "server-name.org" }
-        let!(:store_2) { create :store, default: false, url: url }
-
-        it "returns the store with the matching domain" do
-          expect(subject).to eq(store_2)
-        end
-      end
-    end
-
-    it 'is deprecated' do
-      expect(Spree::Deprecation).to(receive(:warn))
-      Spree::Core::CurrentStore.new(double)
-    end
-  end
-end

data/spec/lib/spree/core/environment_extension_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'spree/core/environment_extension'
-
-RSpec.describe Spree::Core::EnvironmentExtension do
-  let(:base) { Class.new { def self.to_s; 'ExampleClass'; end } }
-  subject! { base.include(described_class).new }
-
-  describe '.add_class_set' do
-    context 'with a class set named "foo"' do
-      before { base.add_class_set('foo') }
-
-      let(:class_one) { String }
-      let(:class_two) { Array }
-      let(:class_three) { Hash }
-
-      describe '#foo' do
-        it { respond_to?(:foo) }
-        it { expect(subject.foo).to be_empty }
-        it { expect(subject.foo).to be_kind_of Spree::Core::ClassConstantizer::Set }
-      end
-
-      describe '#foo=' do
-        it { respond_to?(:foo=) }
-
-        before { subject.foo = [class_one, class_two] }
-
-        it { expect(subject.foo).to include(class_one) }
-        it { expect(subject.foo).to include(class_two) }
-        it { expect(subject.foo).not_to include(class_three) }
-      end
-    end
-  end
-
-  describe '#add_class' do
-    it 'is deprecated' do
-      expect(Spree::Deprecation).to receive(:warn) do |message, _caller|
-        expect(message).to include('ExampleClass.add_class_set(:foo)')
-      end
-      expect(base).to receive(:add_class_set).with(:foo)
-
-      base.new.add_class(:foo)
-    end
-  end
-end