solidus_core 2.10.0 → 2.11.0

data/spec/lib/spree/money_spec.rb

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Money do
-  before do
-    stub_spree_preferences(currency: "USD")
-  end
-
-  describe '#initialize' do
-    subject do
-      Spree::Deprecation.silence do
-        described_class.new(amount, currency: currency, with_currency: true).to_s
-      end
-    end
-
-    context 'with no currency' do
-      let(:currency) { nil }
-      let(:amount){ 10 }
-      it { should == "$10.00 USD" }
-    end
-
-    context 'with currency' do
-      let(:currency){ 'USD' }
-
-      context "CAD" do
-        let(:amount){ '10.00' }
-        let(:currency){ 'CAD' }
-        it { should == "$10.00 CAD" }
-      end
-
-      context "with string amount" do
-        let(:amount){ '10.00' }
-        it { should == "$10.00 USD" }
-      end
-
-      context "with no decimal point" do
-        let(:amount){ '10' }
-        it { should == "$10.00 USD" }
-      end
-
-      context "with symbol" do
-        let(:amount){ '$10.00' }
-        it { should == "$10.00 USD" }
-      end
-
-      context "with extra currency" do
-        let(:amount){ '$10.00 USD' }
-        it { should == "$10.00 USD" }
-      end
-
-      context "with different currency" do
-        let(:currency){ 'USD' }
-        let(:amount){ '$10.00 CAD' }
-        it { should == "$10.00 CAD" }
-      end
-
-      context "with commas" do
-        let(:amount){ '1,000.00' }
-        it { should == "$1,000.00 USD" }
-      end
-
-      context "with comma for decimal point" do
-        let(:amount){ '10,00' }
-        it { should == "$10.00 USD" }
-      end
-
-      context 'with fixnum' do
-        let(:amount){ 10 }
-        it { should == "$10.00 USD" }
-      end
-
-      context 'with float' do
-        let(:amount){ 10.00 }
-        it { should == "$10.00 USD" }
-      end
-
-      context 'with BigDecimal' do
-        let(:amount){ BigDecimal('10.00') }
-        it { should == "$10.00 USD" }
-      end
-    end
-  end
-
-  it "formats correctly" do
-    money = Spree::Money.new(10)
-    expect(money.to_s).to eq("$10.00")
-  end
-
-  it "can get cents" do
-    money = Spree::Money.new(10)
-    expect(money.cents).to eq(1000)
-  end
-
-  context "with currency" do
-    it "passed in option" do
-      money = Spree::Money.new(10, with_currency: true, html_wrap: false)
-      expect(money.to_s).to eq("$10.00 USD")
-    end
-  end
-
-  context "hide cents" do
-    it "hides cents suffix" do
-      money = Spree::Money.new(10, no_cents: true)
-      expect(money.to_s).to eq("$10")
-    end
-
-    it "shows cents suffix" do
-      money = Spree::Money.new(10)
-      expect(money.to_s).to eq("$10.00")
-    end
-  end
-
-  context "currency parameter" do
-    context "when currency is specified in Canadian Dollars" do
-      it "uses the currency param over the global configuration" do
-        money = Spree::Money.new(10, currency: 'CAD', with_currency: true, html_wrap: false)
-        expect(money.to_s).to eq("$10.00 CAD")
-      end
-    end
-
-    context "when currency is specified in Japanese Yen" do
-      it "uses the currency param over the global configuration" do
-        money = Spree::Money.new(100, currency: 'JPY', html_wrap: false)
-        expect(money.to_s).to eq("¥100")
-      end
-    end
-  end
-
-  context "symbol positioning" do
-    it "passed in option" do
-      money = Spree::Money.new(10, format: '%n %u', html_wrap: false)
-      expect(money.to_s).to eq("10.00 $")
-    end
-
-    it "config option" do
-      money = Spree::Money.new(10, format: '%n %u', html_wrap: false)
-      expect(money.to_s).to eq("10.00 $")
-    end
-  end
-
-  context "sign before symbol" do
-    it "defaults to -$10.00" do
-      money = Spree::Money.new(-10)
-      expect(money.to_s).to eq("-$10.00")
-    end
-
-    it "passed in option" do
-      money = Spree::Money.new(-10, sign_before_symbol: false)
-      expect(money.to_s).to eq("$-10.00")
-    end
-  end
-
-  context "JPY" do
-    before do
-      stub_spree_preferences(currency: "JPY")
-    end
-
-    it "formats correctly" do
-      money = Spree::Money.new(1000, html_wrap: false)
-      expect(money.to_s).to eq("¥1,000")
-    end
-  end
-
-  context "EUR" do
-    before do
-      stub_spree_preferences(currency: "EUR")
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/2634
-    it "formats as plain by default" do
-      money = Spree::Money.new(10, format: '%n %u')
-      expect(money.to_s).to eq("10.00 €")
-    end
-
-    it "formats as HTML if asked (nicely) to" do
-      money = Spree::Money.new(10, format: '%n %u')
-      # The HTML'ified version of "10.00 €"
-      expect(money.to_html).to eq("<span class=\"money-whole\">10</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">00</span> <span class=\"money-currency-symbol\">&#x20AC;</span>")
-    end
-
-    it "formats as HTML with currency" do
-      money = Spree::Money.new(10, format: '%n %u', with_currency: true)
-      # The HTML'ified version of "10.00 €"
-      expect(money.to_html).to eq("<span class=\"money-whole\">10</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">00</span> <span class=\"money-currency-symbol\">&#x20AC;</span> <span class=\"money-currency\">EUR</span>")
-    end
-  end
-
-  describe "#as_json" do
-    let(:options) { double('options') }
-
-    it "returns the expected string" do
-      money = Spree::Money.new(10)
-      expect(money.as_json(options)).to eq("$10.00")
-    end
-  end
-
-  describe 'subtraction' do
-    context "for money objects with same currency" do
-      let(:money_1) { Spree::Money.new(32.00, currency: "USD") }
-      let(:money_2) { Spree::Money.new(15.00, currency: "USD") }
-
-      it "subtracts correctly" do
-        expect(money_1 - money_2).to eq(Spree::Money.new(17.00, currency: "USD"))
-      end
-    end
-
-    context "when trying to subtract money objects in different currencies" do
-      let(:money_1) { Spree::Money.new(32.00, currency: "EUR") }
-      let(:money_2) { Spree::Money.new(15.00, currency: "USD") }
-
-      it "will not work" do
-        expect { money_1 - money_2 }.to raise_error(Money::Bank::UnknownRate)
-      end
-    end
-
-    context "if other does not respond to .money" do
-      let(:money_1) { Spree::Money.new(32.00, currency: "EUR") }
-      let(:money_2) { ::Money.new(1500) }
-
-      it 'raises a TypeError' do
-        expect { money_1 - money_2 }.to raise_error(TypeError)
-      end
-    end
-  end
-
-  describe 'addition' do
-    context "for money objects with same currency" do
-      let(:money_1) { Spree::Money.new(37.00, currency: "USD") }
-      let(:money_2) { Spree::Money.new(15.00, currency: "USD") }
-
-      it "subtracts correctly" do
-        expect(money_1 + money_2).to eq(Spree::Money.new(52.00, currency: "USD"))
-      end
-    end
-
-    context "when trying to subtract money objects in different currencies" do
-      let(:money_1) { Spree::Money.new(32.00, currency: "EUR") }
-      let(:money_2) { Spree::Money.new(15.00, currency: "USD") }
-
-      it "will not work" do
-        expect { money_1 + money_2 }.to raise_error(Money::Bank::UnknownRate)
-      end
-    end
-
-    context "if other does not respond to .money" do
-      let(:money_1) { Spree::Money.new(32.00, currency: "EUR") }
-      let(:money_2) { ::Money.new(1500) }
-
-      it 'raises a TypeError' do
-        expect { money_1 + money_2 }.to raise_error(TypeError)
-      end
-    end
-  end
-
-  describe 'equality checks' do
-    context "if other does not respond to .money" do
-      let(:money_1) { Spree::Money.new(32.00, currency: "EUR") }
-      let(:money_2) { ::Money.new(1500) }
-
-      it 'raises a TypeError' do
-        expect { money_1 == money_2 }.to raise_error(TypeError)
-      end
-    end
-  end
-
-  it "includes Comparable" do
-    expect(described_class).to include(Comparable)
-  end
-
-  describe "<=>" do
-    let(:usd_10) { Spree::Money.new(10, currency: "USD") }
-    let(:usd_20) { Spree::Money.new(20, currency: "USD") }
-    let(:usd_30) { Spree::Money.new(30, currency: "USD") }
-
-    it "compares the two amounts" do
-      expect(usd_20 <=> usd_20).to eq 0
-      expect(usd_20 <=> usd_10).to be > 0
-      expect(usd_20 <=> usd_30).to be < 0
-    end
-
-    context "with a non Spree::Money object" do
-      it "raises an error" do
-        expect { usd_10 <=> 20 }.to raise_error(TypeError)
-      end
-    end
-
-    context "with differing currencies" do
-      let(:cad) { Spree::Money.new(10, currency: "CAD") }
-
-      it "raises an error" do
-        expect { usd_10 <=> cad }.to raise_error(
-          Spree::Money::DifferentCurrencyError
-        )
-      end
-    end
-  end
-end

data/spec/lib/spree/permission_sets/default_customer_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PermissionSets::DefaultCustomer do
-  context 'as Guest User' do
-    context 'for Order' do
-      context 'guest_token is empty string' do
-        let(:ability) { Spree::Ability.new(nil) }
-        let(:resource) { build(:order) }
-        let(:token) { '' }
-
-        it 'should not be allowed to read or update the order' do
-          allow(resource).to receive_messages(guest_token: '')
-
-          expect(ability).to_not be_able_to(:read, resource, token)
-          expect(ability).to_not be_able_to(:update, resource, token)
-        end
-      end
-    end
-  end
-end

data/spec/lib/spree/promo/environment_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'spree/core/environment/promotions'
-require 'spree/promo/environment'
-
-RSpec.describe 'Spree::Promo::Environment' do
-  it 'is deprecated' do
-    expect(Spree::Deprecation).to receive(:warn)
-
-    Spree::Promo::Environment.new
-  end
-
-  context 'when customized' do
-    after do
-      # This is needed to cleanup classes after the following specs run.
-      # They will add two new methods but we don't want them to be defined
-      # on the described class for specs that will run later.
-      Spree::Core::Environment::Promotions.remove_method :custom_rules, :custom_rules=
-    end
-
-    context 'with class_eval' do
-      it 'raises a deprecation warning but keep changes' do
-        expect(Spree::Deprecation).to receive(:warn)
-
-        Spree::Promo::Environment.class_eval do
-          add_class_set :custom_rules
-        end
-
-        promo_environment_instance = Spree::Core::Environment::Promotions.new
-        expect(promo_environment_instance).to respond_to(:custom_rules)
-        expect(promo_environment_instance).to respond_to(:custom_rules=)
-      end
-    end
-
-    context 'with prepend' do
-      it 'raises a deprecation warning but keep changes' do
-        expect(Spree::Deprecation).to receive(:warn)
-
-        module CustomRules
-          def self.prepended(base)
-            base.add_class_set :custom_rules
-          end
-        end
-        Spree::Promo::Environment.prepend CustomRules
-
-        promo_environment_instance = Spree::Core::Environment::Promotions.new
-        expect(promo_environment_instance).to respond_to(:custom_rules)
-        expect(promo_environment_instance).to respond_to(:custom_rules=)
-      end
-    end
-  end
-end

data/spec/lib/tasks/dummy_task.rake

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# This is a dummy task used for generic rake task testing
-
-task dummy_task: :environment do
-  DummyTaskRunner.run
-end
-
-class DummyTaskRunner
-  def self.run
-  end
-end

data/spec/lib/tasks/dummy_task_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe 'dummy_task' do
-  include_context(
-    'rake',
-    task_name: 'dummy_task',
-    task_path: Spree::Core::Engine.root.join('spec/lib/tasks/dummy_task.rake'),
-  )
-
-  it 'calls the dummy task exactly once' do
-    expect(DummyTaskRunner).to receive(:run).once
-    task.invoke
-  end
-
-  # This tests:
-  #   1) that tasks get reenabled between examples
-  #   2) that tasks aren't loaded in the wrong way, causing them to execute
-  #      an extra time for every example that's defined.
-  # We need at least two specs to trigger the error conditions and spec order is
-  # random so we just create the same spec twice. We could probably combine this
-  # with the generic spec above but this seems clearer.
-  2.times do |i|
-    it "still calls the dummy task exactly once when more than one example is defined - #{i}" do
-      expect(DummyTaskRunner).to receive(:run).once
-      task.invoke
-    end
-  end
-end

data/spec/lib/tasks/migrations/migrate_shipping_rate_taxes_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe 'solidus:migrations:migrate_shipping_rate_taxes' do
-  describe 'up' do
-    include_context(
-      'rake',
-      task_path: Spree::Core::Engine.root.join('lib/tasks/migrations/migrate_shipping_rate_taxes.rake'),
-      task_name: 'solidus:migrations:migrate_shipping_rate_taxes:up',
-    )
-
-    it 'runs' do
-      Spree::Deprecation.silence do
-        expect { task.invoke }.to output(
-          "Adding persisted tax notes to historic shipping rates ... Success.\n"
-        ).to_stdout
-      end
-    end
-  end
-end

data/spec/mailers/carton_mailer_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::CartonMailer do
-  let(:carton) { create(:carton) }
-  let(:order) { carton.orders.first }
-
-  # Regression test for https://github.com/spree/spree/issues/2196
-  it "doesn't include out of stock in the email body" do
-    shipment_email = Spree::CartonMailer.shipped_email(order: order, carton: carton)
-    expect(shipment_email.parts.first.body).not_to include(%{Out of Stock})
-    expect(shipment_email.parts.first.body).to include(%{Your order has been shipped})
-    expect(shipment_email.subject).to eq "#{order.store.name} Shipment Notification ##{order.number}"
-  end
-
-  context "with resend option" do
-    subject do
-      Spree::CartonMailer.shipped_email(order: order, carton: carton, resend: true).subject
-    end
-    it { is_expected.to match /^\[RESEND\] / }
-  end
-
-  context "emails must be translatable" do
-    context "shipped_email" do
-      context "pt-BR locale" do
-        before do
-          pt_br_shipped_email = { spree: { shipment_mailer: { shipped_email: { dear_customer: 'Caro Cliente,' } } } }
-          I18n.backend.store_translations :'pt-BR', pt_br_shipped_email
-          I18n.locale = :'pt-BR'
-        end
-
-        after do
-          I18n.locale = I18n.default_locale
-        end
-
-        specify do
-          shipped_email = Spree::CartonMailer.shipped_email(order: order, carton: carton)
-          expect(shipped_email.parts.first.body).to include("Caro Cliente,")
-        end
-      end
-    end
-  end
-end

data/spec/mailers/order_mailer_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OrderMailer, type: :mailer do
-  let(:order) do
-    order = create(:order)
-    product = stub_model(Spree::Product, name: %{The "BEST" product})
-    variant = stub_model(Spree::Variant, product: product)
-    price = stub_model(Spree::Price, variant: variant, amount: 5.00)
-    store = FactoryBot.build :store, mail_from_address: "store@example.com"
-    line_item = stub_model(Spree::LineItem, variant: variant, order: order, quantity: 1, price: 4.99)
-    allow(variant).to receive_messages(default_price: price)
-    allow(order).to receive_messages(line_items: [line_item])
-    allow(order).to receive(:store).and_return(store)
-    order
-  end
-
-  it "uses the order's store for the from address" do
-    message = Spree::OrderMailer.confirm_email(order)
-    expect(message.from).to eq ["store@example.com"]
-  end
-
-  it "doesn't aggressively escape double quotes in confirmation body" do
-    confirmation_email = Spree::OrderMailer.confirm_email(order)
-    expect(confirmation_email.body).not_to include(""")
-  end
-
-  context "only shows eligible adjustments in emails" do
-    before do
-      create(
-        :adjustment,
-        adjustable: order,
-        order:      order,
-        eligible:   true,
-        label:      'Eligible Adjustment'
-      )
-
-      create(
-        :adjustment,
-        adjustable: order,
-        order:      order,
-        eligible:   false,
-        label:      'Ineligible Adjustment'
-      )
-    end
-
-    let!(:confirmation_email) { Spree::OrderMailer.confirm_email(order) }
-    let!(:cancel_email) { Spree::OrderMailer.cancel_email(order) }
-
-    specify do
-      expect(confirmation_email.body).not_to include("Ineligible Adjustment")
-    end
-
-    specify do
-      expect(cancel_email.body).not_to include("Ineligible Adjustment")
-    end
-  end
-
-  context "displays unit costs from line item" do
-    # Regression test for https://github.com/spree/spree/issues/2772
-
-    # Tests mailer view spree/order_mailer/confirm_email.text.erb
-    specify do
-      confirmation_email = Spree::OrderMailer.confirm_email(order)
-      expect(confirmation_email.parts.first.body).to include("4.99")
-      expect(confirmation_email.parts.first.body).to_not include("5.00")
-    end
-
-    # Tests mailer view spree/order_mailer/cancel_email.text.erb
-    specify do
-      cancel_email = Spree::OrderMailer.cancel_email(order)
-      expect(cancel_email.parts.first.body).to include("4.99")
-      expect(cancel_email.parts.first.body).to_not include("5.00")
-    end
-  end
-
-  context "emails must be translatable" do
-    context "pt-BR locale" do
-      before do
-        I18n.enforce_available_locales = false
-        pt_br_confirm_mail = { spree: { order_mailer: { confirm_email: { dear_customer: 'Caro Cliente,' } } } }
-        pt_br_cancel_mail = { spree: { order_mailer: { cancel_email: { order_summary_canceled: 'Resumo da Pedido [CANCELADA]' } } } }
-        I18n.backend.store_translations :'pt-BR', pt_br_confirm_mail
-        I18n.backend.store_translations :'pt-BR', pt_br_cancel_mail
-        I18n.locale = :'pt-BR'
-      end
-
-      after do
-        I18n.locale = I18n.default_locale
-        I18n.enforce_available_locales = true
-      end
-
-      context "confirm_email" do
-        specify do
-          confirmation_email = Spree::OrderMailer.confirm_email(order)
-          expect(confirmation_email.parts.first.body).to include("Caro Cliente,")
-        end
-      end
-
-      context "cancel_email" do
-        specify do
-          cancel_email = Spree::OrderMailer.cancel_email(order)
-          expect(cancel_email.parts.first.body).to include("Resumo da Pedido [CANCELADA]")
-        end
-      end
-    end
-  end
-
-  context "with preference :send_core_emails set to false" do
-    it "sends no email" do
-      stub_spree_preferences(send_core_emails: false)
-      message = Spree::OrderMailer.confirm_email(order)
-      expect(message.body).to be_blank
-    end
-  end
-end

data/spec/mailers/promotion_code_batch_mailer_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-RSpec.describe Spree::PromotionCodeBatchMailer, type: :mailer do
-  let(:promotion) { create(:promotion, name: "Promotion Test") }
-  let(:promotion_code_batch) do
-    Spree::PromotionCodeBatch.create!(
-      promotion_id: promotion.id,
-      base_code: "test",
-      number_of_codes: 10,
-      email: "test@email.com"
-    )
-  end
-
-  describe "#promotion_code_batch_finished" do
-    subject { described_class.promotion_code_batch_finished(promotion_code_batch) }
-
-    it "sends the email to the email attached to the promotion code batch " do
-      expect(subject.to).to eq([promotion_code_batch.email])
-    end
-
-    it "contains the number of codes created" do
-      expect(subject.body).to include("All 10 codes have been created")
-    end
-
-    it "contains the name of the promotion" do
-      expect(subject.body).to include(promotion.name)
-    end
-  end
-
-  describe "#promotion_code_batch_errored" do
-    before { promotion_code_batch.update(error: "Test error") }
-    subject { described_class.promotion_code_batch_errored(promotion_code_batch) }
-
-    it "sends the email to the email attached to the promotion code batch " do
-      expect(subject.to).to eq([promotion_code_batch.email])
-    end
-
-    it "contains the error" do
-      expect(subject.body).to include("Test error")
-    end
-
-    it "contains the name of the promotion" do
-      expect(subject.body).to include(promotion.name)
-    end
-  end
-end

data/spec/mailers/reimbursement_mailer_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReimbursementMailer, type: :mailer do
-  let(:reimbursement) { create(:reimbursement) }
-
-  it "accepts a reimbursement id as an alternative to a Reimbursement object" do
-    expect(Spree::Reimbursement).to receive(:find).with(reimbursement.id).and_return(reimbursement)
-
-    Spree::ReimbursementMailer.reimbursement_email(reimbursement.id).body
-  end
-
-  context "emails must be translatable" do
-    context "reimbursement_email" do
-      context "pt-BR locale" do
-        before do
-          I18n.enforce_available_locales = false
-          pt_br_shipped_email = { spree: { reimbursement_mailer: { reimbursement_email: { dear_customer: 'Caro Cliente,' } } } }
-          I18n.backend.store_translations :'pt-BR', pt_br_shipped_email
-          I18n.locale = :'pt-BR'
-        end
-
-        after do
-          I18n.locale = I18n.default_locale
-          I18n.enforce_available_locales = true
-        end
-
-        specify do
-          reimbursement_email = Spree::ReimbursementMailer.reimbursement_email(reimbursement)
-          expect(reimbursement_email.parts.first.body).to include("Caro Cliente,")
-        end
-      end
-    end
-  end
-end