solidus_core 2.10.0 → 2.11.0

data/script/rails

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-ENGINE_ROOT = File.expand_path('..', __dir__)
-ENGINE_PATH = File.expand_path('../lib/spree/core/engine', __dir__)
-
-require 'rails/all'
-require 'rails/engine/commands'

data/spec/helpers/base_helper_spec.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::BaseHelper, type: :helper do
-  include Spree::BaseHelper
-
-  let(:current_store){ create :store }
-
-  context "available_countries" do
-    let(:country) { create(:country) }
-
-    before do
-      3.times { create(:country) }
-    end
-
-    context "with no checkout zone defined" do
-      before do
-        stub_spree_preferences(checkout_zone: nil)
-      end
-
-      it "return complete list of countries" do
-        expect(available_countries.count).to eq(Spree::Country.count)
-      end
-
-      it "uses locales for country names" do
-        expect(available_countries).to include(having_attributes(name: "United States of America"))
-      end
-    end
-
-    context "with a checkout zone defined" do
-      context "checkout zone is of type country" do
-        before do
-          @country_zone = create(:zone, name: "CountryZone")
-          @country_zone.members.create(zoneable: country)
-          stub_spree_preferences(checkout_zone: @country_zone.name)
-        end
-
-        it "return only the countries defined by the checkout zone" do
-          expect(available_countries).to eq([country])
-        end
-
-        it "returns only the countries defined by the checkout zone passed as parameter" do
-          expect(available_countries(restrict_to_zone: @country_zone.name)).to eq([country])
-        end
-      end
-
-      context "checkout zone is of type state" do
-        before do
-          state_zone = create(:zone, name: "StateZone")
-          state = create(:state, country: country)
-          state_zone.members.create(zoneable: state)
-          stub_spree_preferences(checkout_zone: state_zone.name)
-        end
-
-        it "return complete list of countries" do
-          expect(available_countries.count).to eq(Spree::Country.count)
-        end
-      end
-    end
-  end
-
-  # Regression test for https://github.com/spree/spree/issues/2034
-  context "flash_message" do
-    let(:flash) { { "notice" => "ok", "foo" => "foo", "bar" => "bar" } }
-
-    it "should output all flash content" do
-      flash_messages
-      html = Nokogiri::HTML(helper.output_buffer)
-      expect(html.css(".notice").text).to eq("ok")
-      expect(html.css(".foo").text).to eq("foo")
-      expect(html.css(".bar").text).to eq("bar")
-    end
-
-    it "should output flash content except one key" do
-      flash_messages(ignore_types: :bar)
-      html = Nokogiri::HTML(helper.output_buffer)
-      expect(html.css(".notice").text).to eq("ok")
-      expect(html.css(".foo").text).to eq("foo")
-      expect(html.css(".bar").text).to be_empty
-    end
-
-    it "should output flash content except some keys" do
-      flash_messages(ignore_types: [:foo, :bar])
-      html = Nokogiri::HTML(helper.output_buffer)
-      expect(html.css(".notice").text).to eq("ok")
-      expect(html.css(".foo").text).to be_empty
-      expect(html.css(".bar").text).to be_empty
-      expect(helper.output_buffer).to eq("<div class=\"flash notice\">ok</div>")
-    end
-  end
-
-  context "link_to_tracking" do
-    it "returns tracking link if available" do
-      a = link_to_tracking_html(shipping_method: true, tracking: '123', tracking_url: 'http://g.c/?t=123').css('a')
-
-      expect(a.text).to eq '123'
-      expect(a.attr('href').value).to eq 'http://g.c/?t=123'
-    end
-
-    it "returns tracking without link if link unavailable" do
-      html = link_to_tracking_html(shipping_method: true, tracking: '123', tracking_url: nil)
-      expect(html.css('span').text).to eq '123'
-    end
-
-    it "returns nothing when no shipping method" do
-      html = link_to_tracking_html(shipping_method: nil, tracking: '123')
-      expect(html.css('span').text).to eq ''
-    end
-
-    it "returns nothing when no tracking" do
-      html = link_to_tracking_html(tracking: nil)
-      expect(html.css('span').text).to eq ''
-    end
-
-    def link_to_tracking_html(options = {})
-      node = link_to_tracking(double(:shipment, options))
-      Nokogiri::HTML(node.to_s)
-    end
-  end
-
-  # Regression test for https://github.com/spree/spree/issues/2396
-  context "meta_data_tags" do
-    it "truncates a product description to 160 characters" do
-      # Because the controller_name method returns "test"
-      # controller_name is used by this method to infer what it is supposed
-      # to be generating meta_data_tags for
-      @test = Spree::Product.new(description: "a" * 200)
-      tags = Nokogiri::HTML.parse(meta_data_tags)
-      content = tags.css("meta[name=description]").first["content"]
-      expect(content.length).to be <= 160
-    end
-  end
-
-  describe "#pretty_time" do
-    subject { pretty_time(date) }
-
-    let(:date) { Time.new(2012, 11, 6, 13, 33) }
-
-    it "pretty prints time in long format" do
-      is_expected.to eq "November 06, 2012 1:33 PM"
-    end
-
-    context 'with format set to short' do
-      subject { pretty_time(date, :short) }
-
-      it "pretty prints time in short format" do
-        is_expected.to eq "Nov 6 '12 1:33pm"
-      end
-    end
-  end
-
-  context "plural_resource_name" do
-    let(:plural_config) { Spree::I18N_GENERIC_PLURAL }
-    let(:base_class) { Spree::Product }
-
-    subject { plural_resource_name(base_class) }
-
-    it "should use ActiveModel::Naming module to pluralize model names" do
-      expect(subject).to eq base_class.model_name.human(count: plural_config)
-    end
-
-    it "should use the Spree::I18N_GENERIC_PLURAL constant" do
-      expect(base_class.model_name).to receive(:human).with(hash_including(count: plural_config))
-      subject
-    end
-  end
-end

data/spec/helpers/products_helper_spec.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe ProductsHelper, type: :helper do
-    include ProductsHelper
-
-    let(:product) { create(:product, price: product_price) }
-    let(:product_price) { 10 }
-    let(:variant) { create(:variant, product: product, price: variant_price) }
-    let(:currency) { 'USD' }
-    let(:pricing_options) do
-      Spree::Config.pricing_options_class.new(currency: currency)
-    end
-
-    before do
-      without_partial_double_verification do
-        allow(helper).to receive(:current_pricing_options) { pricing_options }
-      end
-    end
-
-    context "#variant_price_diff" do
-      let(:variant_price) { 10 }
-
-      subject { helper.variant_price(variant) }
-
-      context "when variant is same as master" do
-        it { is_expected.to be_nil }
-      end
-
-      context "when currency is default" do
-        context "when variant is more than master" do
-          let(:variant_price) { 15 }
-
-          it { is_expected.to eq("(Add: <span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">5</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">00</span>)") }
-          # Regression test for https://github.com/spree/spree/issues/2737
-          it { is_expected.to be_html_safe }
-        end
-
-        context "when variant is less than master" do
-          let(:product_price) { 15 }
-
-          it { is_expected.to eq("(Subtract: <span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">5</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">00</span>)") }
-        end
-      end
-
-      context "when currency is JPY" do
-        let(:variant_price) { 100 }
-        let(:product_price) { 100 }
-        let(:currency) { 'JPY' }
-
-        before do
-          variant
-          product.prices.update_all(currency: currency)
-        end
-
-        context "when variant is more than master" do
-          let(:variant_price) { 150 }
-
-          it { is_expected.to eq("(Add: <span class=\"money-currency-symbol\">&#x00A5;</span><span class=\"money-whole\">50</span>)") }
-        end
-
-        context "when variant is less than master" do
-          let(:product_price) { 150 }
-
-          it { is_expected.to eq("(Subtract: <span class=\"money-currency-symbol\">&#x00A5;</span><span class=\"money-whole\">50</span>)") }
-        end
-      end
-    end
-
-    context "#variant_price_full" do
-      let!(:variant_2) { create(:variant, product: product, price: variant_2_price) }
-      let(:variant_2_price) { 20 }
-      let(:variant_price) { 15 }
-
-      before do
-        stub_spree_preferences(show_variant_full_price: true)
-        variant
-      end
-
-      context "when currency is default" do
-        it "should return the variant price if the price is different than master" do
-          expect(helper.variant_price(variant)).to eq("<span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">15</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">00</span>")
-          expect(helper.variant_price(variant_2)).to eq("<span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">20</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">00</span>")
-        end
-      end
-
-      context "when currency is JPY" do
-        let(:currency) { 'JPY' }
-        let(:product_price) { 100 }
-        let(:variant_price) { 150 }
-
-        before do
-          variant
-          product.prices.update_all(currency: currency)
-        end
-
-        it "should return the variant price if the price is different than master" do
-          expect(helper.variant_price(variant)).to eq("<span class=\"money-currency-symbol\">&#x00A5;</span><span class=\"money-whole\">150</span>")
-        end
-      end
-
-      context "when all variant prices are equal" do
-        let(:product_price) { 10 }
-        let(:variant_price) { 10 }
-        let(:variant_2_price) { 10 }
-
-        it "should be nil" do
-          expect(helper.variant_price(variant)).to be_nil
-          expect(helper.variant_price(variant_2)).to be_nil
-        end
-      end
-    end
-
-    context "#product_description" do
-      # Regression test for https://github.com/spree/spree/issues/1607
-      it "renders a product description without excessive paragraph breaks" do
-        product.description = %{
-<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus a ligula leo. Proin eu arcu at ipsum dapibus ullamcorper. Pellentesque egestas orci nec magna condimentum luctus. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut ac ante et mauris bibendum ultricies non sed massa. Fusce facilisis dui eget lacus scelerisque eget aliquam urna ultricies. Duis et rhoncus quam. Praesent tellus nisi, ultrices sed iaculis quis, euismod interdum ipsum.</p>
-<ul>
-<li>Lorem ipsum dolor sit amet</li>
-<li>Lorem ipsum dolor sit amet</li>
-</ul>
-        }
-        description = product_description(product)
-        expect(description.strip).to eq(product.description.strip)
-      end
-
-      it "renders a product description with automatic paragraph breaks" do
-        product.description = %{
-THIS IS THE BEST PRODUCT EVER!
-
-"IT CHANGED MY LIFE" - Sue, MD}
-
-        description = product_description(product)
-        expect(description.strip).to eq(%{<p>\nTHIS IS THE BEST PRODUCT EVER!</p>"IT CHANGED MY LIFE" - Sue, MD})
-      end
-
-      it "renders a product description without any formatting based on configuration" do
-        description = %{
-            <p>hello world</p>
-
-            <p>tihs is completely awesome and it works</p>
-
-            <p>why so many spaces in the code. and why some more formatting afterwards?</p>
-        }
-
-        product.description = description
-
-        stub_spree_preferences(show_raw_product_description: true)
-        description = product_description(product)
-        expect(description).to eq(description)
-      end
-    end
-
-    context '#line_item_description_text' do
-      subject { line_item_description_text description }
-      context 'variant has a blank description' do
-        let(:description) { nil }
-        it { is_expected.to eq(I18n.t('spree.product_has_no_description')) }
-      end
-      context 'variant has a description' do
-        let(:description) { 'test_desc' }
-        it { is_expected.to eq(description) }
-      end
-      context 'description has nonbreaking spaces' do
-        let(:description) { 'test&nbsp;desc' }
-        it { is_expected.to eq('test desc') }
-      end
-    end
-
-    context '#cache_key_for_products' do
-      subject { helper.cache_key_for_products }
-      before(:each) do
-        @products = double('products collection')
-        allow(helper).to receive(:params) { { page: 10 } }
-      end
-
-      context 'when there is a maximum updated date' do
-        let(:updated_at) { Date.new(2011, 12, 13) }
-        before :each do
-          allow(@products).to receive(:count) { 5 }
-          allow(@products).to receive(:maximum).with(:updated_at) { updated_at }
-        end
-
-        it { is_expected.to eq('en/USD/spree/products/all-10-20111213-5') }
-      end
-
-      context 'when there is no considered maximum updated date' do
-        let(:today) { Date.new(2013, 12, 11) }
-        before :each do
-          allow(@products).to receive(:count) { 1_234_567 }
-          allow(@products).to receive(:maximum).with(:updated_at) { nil }
-          allow(Date).to receive(:today) { today }
-        end
-
-        it { is_expected.to eq('en/USD/spree/products/all-10-20131211-1234567') }
-      end
-    end
-  end
-end

data/spec/helpers/taxons_helper_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::TaxonsHelper, type: :helper do
-  let(:currency) { 'USD' }
-  let(:pricing_options) do
-    Spree::Config.pricing_options_class.new(currency: currency)
-  end
-  before do
-    without_partial_double_verification do
-      allow(helper).to receive(:current_pricing_options) { pricing_options }
-    end
-  end
-
-  describe "#taxon_preview" do
-    let!(:taxon) { create(:taxon) }
-    let!(:child_taxon) { create(:taxon, parent: taxon) }
-    let!(:product_1) { create(:product) }
-    let!(:product_2) { create(:product) }
-    let!(:product_3) { create(:product) }
-
-    before do
-      taxon.products << product_1
-      taxon.products << product_2
-      child_taxon.products << product_3
-      taxon.reload
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/4382
-    it "returns products" do
-      expect(helper.taxon_preview(taxon)).to eql([product_1, product_2, product_3])
-    end
-
-    context "with different currency" do
-      let(:currency) { 'CAD' }
-
-      it "returns no products" do
-        expect(helper.taxon_preview(taxon)).to be_empty
-      end
-    end
-  end
-end

data/spec/jobs/promotion_code_batch_job_spec.rb

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

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