solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/jobs/promotion_code_batch_job_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+RSpec.describe Spree::PromotionCodeBatchJob, type: :job do
+  let(:email) { "test@email.com" }
+  let(:promotion_code_batch) do
+    Spree::PromotionCodeBatch.create!(
+      promotion_id: create(:promotion).id,
+      base_code: "test",
+      number_of_codes: 10,
+      email: email
+    )
+  end
+  context "with a successful build" do
+    before do
+      allow(Spree::PromotionCodeBatchMailer)
+        .to receive(:promotion_code_batch_finished)
+        .and_call_original
+    end
+
+    def codes
+      Spree::PromotionCode.pluck(:value)
+    end
+
+    context 'with the default join character' do
+      it 'uses the default join characters', :aggregate_failures do
+        subject.perform(promotion_code_batch)
+        codes.each do |code|
+          expect(code).to match(/^test_/)
+        end
+      end
+    end
+    context 'with a custom join character' do
+      let(:promotion_code_batch) do
+        Spree::PromotionCodeBatch.create!(
+          promotion_id: create(:promotion).id,
+          base_code: "test",
+          number_of_codes: 10,
+          email: email,
+          join_characters: '-'
+        )
+      end
+      it 'uses the custom join characters', :aggregate_failures do
+        subject.perform(promotion_code_batch)
+        codes.each do |code|
+          expect(code).to match(/^test-/)
+        end
+      end
+    end
+    context "with an email address" do
+      it "sends an email" do
+        subject.perform(promotion_code_batch)
+        expect(Spree::PromotionCodeBatchMailer)
+          .to have_received(:promotion_code_batch_finished)
+      end
+    end
+    context "with no email address" do
+      let(:email) { nil }
+      it "sends an email" do
+        subject.perform(promotion_code_batch)
+        expect(Spree::PromotionCodeBatchMailer)
+          .to_not have_received(:promotion_code_batch_finished)
+      end
+    end
+  end
+
+  context "with a failed build" do
+    before do
+      allow_any_instance_of(Spree::PromotionCode::BatchBuilder)
+        .to receive(:build_promotion_codes)
+        .and_raise("Error")
+
+      allow(Spree::PromotionCodeBatchMailer)
+        .to receive(:promotion_code_batch_errored)
+        .and_call_original
+
+      expect { subject.perform(promotion_code_batch) }
+        .to raise_error RuntimeError
+    end
+
+    context "with an email address" do
+      it "sends an email" do
+        expect(Spree::PromotionCodeBatchMailer)
+          .to have_received(:promotion_code_batch_errored)
+      end
+    end
+
+    context "with no email address" do
+      let(:email) { nil }
+      it "sends an email" do
+        expect(Spree::PromotionCodeBatchMailer)
+          .to_not have_received(:promotion_code_batch_errored)
+      end
+    end
+  end
+end

data/spec/lib/calculated_adjustments_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::CalculatedAdjustments do
+  let(:calculator_class) { Spree::Calculator::FlatRate }
+
+  with_model :Calculable, scope: :all do
+    model do
+      include Spree::CalculatedAdjustments
+    end
+  end
+
+  it "should add has_one :calculator relationship" do
+    expect(Calculable.reflect_on_all_associations(:has_one).map(&:name)).to include(:calculator)
+  end
+
+  describe 'initialization' do
+    context 'with no calculator' do
+      subject { Calculable.new }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be nil
+      end
+
+      it 'is not valid' do
+        expect(subject).not_to be_valid
+        expect(subject.errors[:calculator]).to eq ["can't be blank"]
+      end
+    end
+
+    context 'with calculator object' do
+      subject { Calculable.new(calculator: calculator_class.new) }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 0 # not yet saved
+      end
+
+      it 'can be created' do
+        subject.save!
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 1 # saved in database
+      end
+    end
+
+    context 'with calculator_type' do
+      subject { Calculable.new(calculator_type: calculator_class.to_s) }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 0 # not yet saved
+      end
+
+      it 'can be created' do
+        subject.save!
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 1 # saved in database
+      end
+    end
+
+    context 'with calculator_type and calculator_attributes' do
+      subject { Calculable.new(calculator_type: calculator_class.to_s, calculator_attributes: { preferred_amount: 123 }) }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(subject.calculator.preferred_amount).to eq 123
+        expect(calculator_class.count).to eq 0 # not yet saved
+      end
+
+      it 'can be created' do
+        subject.save!
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(subject.calculator.preferred_amount).to eq 123
+        expect(calculator_class.count).to eq 1 # saved in database
+      end
+    end
+  end
+
+  describe 'update' do
+    subject { Calculable.create!(calculator_type: calculator_class.to_s) }
+
+    it "can update calculator attributes with id" do
+      subject.update!(calculator_attributes: {
+        id: subject.calculator.id,
+        preferred_amount: 123
+      })
+      expect(subject.calculator.preferred_amount).to eq(123)
+      subject.reload
+      expect(subject.calculator.preferred_amount).to eq(123)
+    end
+
+    it "can update calculator attributes without id" do
+      subject.update!(calculator_attributes: {
+        preferred_amount: 123
+      })
+      expect(subject.calculator.preferred_amount).to eq(123)
+      subject.reload
+      expect(subject.calculator.preferred_amount).to eq(123)
+    end
+
+    it "can update both calculator type and attributes" do
+      subject.update!(calculator_type: 'Spree::Calculator::FlexiRate', calculator_attributes: {
+        preferred_first_item: 123
+      })
+      expect(subject.calculator.class).to eq(Spree::Calculator::FlexiRate)
+      expect(subject.calculator.preferred_first_item).to eq(123)
+      subject.reload
+      expect(subject.calculator.class).to eq(Spree::Calculator::FlexiRate)
+      expect(subject.calculator.preferred_first_item).to eq(123)
+    end
+  end
+
+  describe '#calculator_type=' do
+    subject { Calculable.new }
+
+    let(:calculator_subclass) { Spree::Calculator::Shipping::FlatRate }
+    let(:calculator_superclass) { Spree::ShippingCalculator }
+
+    before(:each) do
+      subject.calculator_type = calculator_subclass.to_s
+    end
+
+    it 'sets calculator type' do
+      expect(subject.calculator_type).to eq(calculator_subclass.to_s)
+    end
+
+    it 'switches from calculator subclass to calculator superclass' do
+      subject.calculator_type = calculator_superclass.to_s
+      expect(subject.calculator_type).to eq(calculator_superclass.to_s)
+    end
+  end
+end

data/spec/lib/i18n_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'spree/i18n'
+
+RSpec.describe "i18n" do
+  before do
+    # This reload avoids an issue with I18n.available_locales being cached
+    I18n.reload!
+
+    I18n.backend.store_translations(:en,
+    {
+      spree: {
+        i18n: {
+          this_file_language: "English"
+        },
+        foo: "bar",
+        bar: {
+          foo: "bar within bar scope",
+          invalid: nil,
+          legacy_translation: "back in the day..."
+        },
+        invalid: nil,
+        legacy_translation: "back in the day..."
+      }
+    })
+  end
+  after do
+    I18n.reload!
+  end
+
+  it "translates within the spree scope" do
+    expect(Spree.t(:foo)).to eql("bar")
+    expect(Spree.translate(:foo)).to eql("bar")
+  end
+
+  it "prepends a string scope" do
+    expect(Spree.t(:foo, scope: "bar")).to eql("bar within bar scope")
+  end
+
+  it "prepends to an array scope" do
+    expect(Spree.t(:foo, scope: ["bar"])).to eql("bar within bar scope")
+  end
+
+  it "returns two translations" do
+    expect(Spree.t([:foo, 'bar.foo'])).to eql(["bar", "bar within bar scope"])
+  end
+
+  it "returns reasonable string for missing translations" do
+    expect(Spree.t(:missing_entry)).to include("<span")
+  end
+
+  it "should have a Spree::I18N_GENERIC_PLURAL constant" do
+    expect(Spree::I18N_GENERIC_PLURAL).to eq 2.1
+  end
+
+  describe "i18n_available_locales" do
+    it "should only return :en" do
+      expect(Spree.i18n_available_locales).to eq([:en])
+    end
+
+    context 'with unprefixed translations in another locale' do
+      before do
+        I18n.backend.store_translations(:fr, { cheese: "fromage" })
+      end
+
+      it "should only return :en" do
+        expect(Spree.i18n_available_locales).to eq([:en])
+      end
+    end
+
+    context 'with spree-prefixed translations in another locale' do
+      before do
+        I18n.backend.store_translations(:fr, spree: { cheese: "fromage" })
+      end
+
+      it "should return :en and :fr" do
+        expect(Spree.i18n_available_locales).to eq([:en])
+      end
+    end
+
+    context 'with specific desired key' do
+      before do
+        I18n.backend.store_translations(:fr, spree: { i18n: { this_file_language: "Français" } })
+      end
+
+      it "should return :en and :fr" do
+        expect(Spree.i18n_available_locales).to eq([:en, :fr])
+      end
+    end
+  end
+end

data/spec/lib/search/base_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'spree/core/product_filters'
+
+RSpec.describe Spree::Core::Search::Base do
+  before do
+    include Spree::Core::ProductFilters
+    @taxon = create(:taxon, name: "Ruby on Rails")
+
+    @product1 = create(:product, name: "RoR Mug", price: 9.00)
+    @product1.taxons << @taxon
+    @product2 = create(:product, name: "RoR Shirt", price: 11.00)
+  end
+
+  it "returns all products by default" do
+    params = { per_page: "" }
+    searcher = Spree::Core::Search::Base.new(params)
+    expect(searcher.retrieve_products.count).to eq(2)
+  end
+
+  context "when include_images is included in the initalization params" do
+    let(:params) { { include_images: true, keyword: @product1.name, taxon: @taxon.id } }
+    subject { described_class.new(params).retrieve_products }
+
+    before do
+      @product1.master.images.create(attachment_file_name: "Test", position: 2)
+      @product1.master.images.create(attachment_file_name: "Test1", position: 1)
+      @product1.reload
+    end
+
+    it "returns images in correct order" do
+      expect(subject.first).to eq @product1
+      expect(subject.first.images).to eq @product1.master.images
+    end
+  end
+
+  it "switches to next page according to the page parameter" do
+    @product3 = create(:product, name: "RoR Pants", price: 14.00)
+
+    params = { per_page: "2" }
+    searcher = Spree::Core::Search::Base.new(params)
+    expect(searcher.retrieve_products.count).to eq(2)
+
+    params[:page] = "2"
+    searcher = Spree::Core::Search::Base.new(params)
+    expect(searcher.retrieve_products.count).to eq(1)
+  end
+
+  it "maps search params to named scopes" do
+    params = { per_page: "",
+               search: { "price_range_any" => ["Under $10.00"] } }
+    searcher = Spree::Core::Search::Base.new(params)
+    expect(searcher.send(:get_base_scope).to_sql).to match /<= 10/
+    expect(searcher.retrieve_products.count).to eq(1)
+  end
+
+  it "maps multiple price_range_any filters" do
+    params = { per_page: "",
+               search: { "price_range_any" => ["Under $10.00", "$10.00 - $15.00"] } }
+    searcher = Spree::Core::Search::Base.new(params)
+    expect(searcher.send(:get_base_scope).to_sql).to match /<= 10/
+    expect(searcher.send(:get_base_scope).to_sql).to match /between 10 and 15/i
+    expect(searcher.retrieve_products.count).to eq(2)
+  end
+
+  it "uses ransack if scope not found" do
+    params = { per_page: "",
+               search: { "name_not_cont" => "Shirt" } }
+    searcher = Spree::Core::Search::Base.new(params)
+    expect(searcher.retrieve_products.count).to eq(1)
+  end
+
+  it "accepts a current user" do
+    user = double
+    searcher = Spree::Core::Search::Base.new({})
+    searcher.current_user = user
+    expect(searcher.current_user).to eql(user)
+  end
+
+  it "finds products in alternate currencies" do
+    create(:price, currency: 'EUR', variant: @product1.master)
+    searcher = Spree::Core::Search::Base.new({})
+    searcher.pricing_options = Spree::Config.pricing_options_class.new(currency: 'EUR')
+    expect(searcher.retrieve_products).to eq([@product1])
+  end
+end

data/spec/lib/search/variant_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Core::Search::Variant do
+    def assert_found(query_string, variant)
+      expect(described_class.new(query_string).results).to include variant
+    end
+
+    def refute_found(query_string, variant)
+      expect(described_class.new(query_string).results).not_to include variant
+    end
+
+    let(:product) { FactoryBot.create(:product, name: "My Special Product", slug: "my-special-product") }
+    let!(:variant) { FactoryBot.create(:variant, product: product, sku: "abc-123") }
+
+    context "blank string" do
+      it { assert_found(nil, variant) }
+      it { assert_found("", variant) }
+    end
+
+    context "by sku" do
+      it { assert_found("abc-123", variant) }
+      it { assert_found("abc-1", variant) }
+      it { assert_found("aBc-12", variant) }
+      it { refute_found("bca", variant) }
+    end
+
+    context "by product" do
+      it { assert_found("My Special Product", variant) }
+      it { assert_found("My Spec", variant) }
+      it { assert_found("my spec", variant) }
+      it { assert_found("my-special-product", variant) }
+      it { assert_found("my-spec", variant) }
+      it { assert_found("mY-sPec", variant) }
+      it { assert_found("My Product", variant) }
+      it { refute_found("My House", variant) }
+      it { refute_found("my-product", variant) }
+    end
+
+    context "by product + options" do
+      before do
+        variant.option_values << create(:option_value, presentation: "Robin's egg", name: "blue")
+        variant.option_values << create(:option_value, presentation: 'Slim')
+        variant.option_values << create(:option_value, presentation: '30')
+      end
+      it { assert_found("My Spec blue", variant) }
+      it { assert_found("My Spec robin egg Slim", variant) }
+      it { assert_found("My Spec 30 slim", variant) }
+      it { refute_found("My Spec red slim", variant) }
+      it { refute_found("foo product blue slim", variant) }
+    end
+
+    context "custom scope" do
+      it "takes into account a passed in scope" do
+        variant.stock_items.first.set_count_on_hand(10)
+        expect(
+          described_class.new(variant.sku, scope: Spree::Variant.in_stock).results
+        ).to include variant
+
+        variant.stock_items.each { |si| si.set_count_on_hand(0) }
+        expect(
+          described_class.new(variant.sku, scope: Spree::Variant.in_stock).results
+        ).not_to include variant
+      end
+    end
+
+    context "custom search configuration" do
+      context "removing a search query" do
+        around do |example|
+          search_terms = described_class.search_terms
+          described_class.search_terms -= [:sku_cont]
+          example.run
+          described_class.search_terms = search_terms
+        end
+
+        it { refute_found("abc-123", variant) }
+      end
+
+      context "adding a search query" do
+        around do |example|
+          search_terms = described_class.search_terms
+          described_class.search_terms += [:weight_eq]
+          example.run
+          described_class.search_terms = search_terms
+        end
+        before { variant.update_attributes!(weight: 5000) }
+
+        it { assert_found("5000", variant) }
+      end
+    end
+
+    describe '#search_terms' do
+      # Only search by SKU if the search word is a number
+      class NumericSkuSearcher < Core::Search::Variant
+        protected
+
+        def search_terms(word)
+          if word =~ /\A\d+\z/
+            super
+          else
+            super - [:sku_cont]
+          end
+        end
+      end
+
+      let!(:numeric_sku_variant) { FactoryBot.create(:variant, product: product, sku: "123") }
+      let!(:non_numeric_sku_variant) { FactoryBot.create(:variant, product: product, sku: "abc") }
+
+      it { expect(NumericSkuSearcher.new('123').results).to include numeric_sku_variant }
+      it { expect(NumericSkuSearcher.new('abc').results).not_to include non_numeric_sku_variant }
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'spree/core/class_constantizer'
+
+module ClassConstantizerTest
+  ClassA = Class.new
+  ClassB = Class.new
+
+  def self.reload
+    [:ClassA, :ClassB].each do |klass|
+      remove_const(klass)
+      const_set(klass, Class.new)
+    end
+  end
+end
+
+RSpec.describe Spree::Core::ClassConstantizer::Set do
+  let(:set) { described_class.new }
+
+  describe "#concat" do
+    it "can add one item" do
+      set.concat(['ClassConstantizerTest::ClassA'])
+      expect(set).to include(ClassConstantizerTest::ClassA)
+    end
+
+    it "can add two items" do
+      set.concat(['ClassConstantizerTest::ClassA', ClassConstantizerTest::ClassB])
+      expect(set).to include(ClassConstantizerTest::ClassA)
+      expect(set).to include(ClassConstantizerTest::ClassB)
+    end
+  end
+
+  describe "<<" do
+    it "can add by string" do
+      set << "ClassConstantizerTest::ClassA"
+      expect(set).to include(ClassConstantizerTest::ClassA)
+    end
+
+    it "can add by class" do
+      set << ClassConstantizerTest::ClassA
+      expect(set).to include(ClassConstantizerTest::ClassA)
+    end
+
+    describe "class redefinition" do
+      shared_examples "working code reloading" do
+        it "works with a class" do
+          original = ClassConstantizerTest::ClassA
+
+          ClassConstantizerTest.reload
+
+          # Sanity check
+          expect(original).not_to eq(ClassConstantizerTest::ClassA)
+
+          expect(set).to include(ClassConstantizerTest::ClassA)
+          expect(set).to_not include(original)
+        end
+      end
+
+      context "with a class" do
+        before { set << ClassConstantizerTest::ClassA }
+        it_should_behave_like "working code reloading"
+      end
+
+      context "with a string" do
+        before { set << "ClassConstantizerTest::ClassA" }
+        it_should_behave_like "working code reloading"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+class FakesController < ApplicationController
+  include Spree::Core::ControllerHelpers::Auth
+  def index; render plain: 'index'; end
+end
+
+RSpec.describe Spree::Core::ControllerHelpers::Auth, type: :controller do
+  controller(FakesController) {}
+
+  describe '#current_ability' do
+    it 'returns Spree::Ability instance' do
+      expect(controller.current_ability.class).to eq Spree::Ability
+    end
+  end
+
+  describe '#redirect_back_or_default' do
+    controller(FakesController) do
+      def index; redirect_back_or_default('/'); end
+    end
+    it 'redirects to session url' do
+      session[:spree_user_return_to] = '/redirect'
+      get :index
+      expect(response).to redirect_to('/redirect')
+    end
+    it 'redirects to default page' do
+      get :index
+      expect(response).to redirect_to('/')
+    end
+  end
+
+  describe '#set_guest_token' do
+    controller(FakesController) do
+      def index
+        set_guest_token
+        render plain: 'index'
+      end
+    end
+    it 'sends cookie header' do
+      get :index
+      expect(response.headers["Set-Cookie"]).to match(/guest_token.*HttpOnly/)
+      expect(response.cookies['guest_token']).not_to be_nil
+    end
+  end
+
+  describe '#store_location' do
+    it 'sets session return url' do
+      allow(controller).to receive_messages(request: double(fullpath: '/redirect'))
+      controller.store_location
+      expect(session[:spree_user_return_to]).to eq '/redirect'
+    end
+  end
+
+  describe '#try_spree_current_user' do
+    it 'calls spree_current_user when define spree_current_user method' do
+      expect(controller).to receive(:spree_current_user)
+      controller.try_spree_current_user
+    end
+    it 'calls current_spree_user when define current_spree_user method' do
+      expect(controller).to receive(:current_spree_user)
+      controller.try_spree_current_user
+    end
+    it 'returns nil' do
+      expect(controller.try_spree_current_user).to eq nil
+    end
+  end
+end