solidus_core_devise_token_auth 2.8.0.alpha.0

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

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

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

@@ -0,0 +1,81 @@
+# 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
+  end
+end

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

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

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

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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'spree/core/environment_extension'
+
+class DummyClass
+  include Spree::Core::EnvironmentExtension
+end
+
+class C1; end
+class C2; end
+class C3; end
+
+RSpec.describe Spree::Core::EnvironmentExtension do
+  subject { DummyClass.new }
+
+  before { subject.add_class('random_name') }
+
+  describe 'Basis' do
+    it { respond_to?(:random_name) }
+    it { respond_to?(:random_name=) }
+  end
+
+  describe '#getter' do
+    it { expect(subject.random_name).to be_empty }
+    it { expect(subject.random_name).to be_kind_of Spree::Core::ClassConstantizer::Set }
+  end
+
+  describe '#setter' do
+    before { subject.random_name = [C1, C2]; @set = subject.random_name.to_a }
+
+    it { expect(@set).to include(C1) }
+    it { expect(@set).to include(C2) }
+    it { expect(@set).not_to include(C3) }
+  end
+end