solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/lib/spree/money_spec.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'spree/money'
+
+RSpec.describe Spree::Money do
+  before do
+    configure_spree_preferences do |config|
+      config.currency = "USD"
+    end
+  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: 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: 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: 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, symbol_position: :after, html: false)
+      expect(money.to_s).to eq("10.00 $")
+    end
+
+    it "config option" do
+      money = Spree::Money.new(10, symbol_position: :after, html: 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
+      configure_spree_preferences do |config|
+        config.currency = "JPY"
+      end
+    end
+
+    it "formats correctly" do
+      money = Spree::Money.new(1000, html: false)
+      expect(money.to_s).to eq("¥1,000")
+    end
+  end
+
+  context "EUR" do
+    before do
+      configure_spree_preferences do |config|
+        config.currency = "EUR"
+      end
+    end
+
+    # Regression test for https://github.com/spree/spree/issues/2634
+    it "formats as plain by default" do
+      money = Spree::Money.new(10, symbol_position: :after)
+      expect(money.to_s).to eq("10.00 €")
+    end
+
+    it "formats as HTML if asked (nicely) to" do
+      money = Spree::Money.new(10, symbol_position: :after)
+      # The HTML'ified version of "10.00 €"
+      expect(money.to_html).to eq("10.00 €")
+    end
+
+    it "formats as HTML with currency" do
+      money = Spree::Money.new(10, symbol_position: :after, with_currency: true)
+      # The HTML'ified version of "10.00 €"
+      expect(money.to_html).to eq("10.00&nbsp;&#x20AC; <span class=\"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

@@ -0,0 +1,22 @@
+# 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/tasks/dummy_task.rake

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

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

@@ -0,0 +1,19 @@
+# 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
+      expect { task.invoke }.to output(
+        "Adding persisted tax notes to historic shipping rates ... Success.\n"
+      ).to_stdout
+    end
+  end
+end

data/spec/mailers/carton_mailer_spec.rb

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

@@ -0,0 +1,117 @@
+# 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
+      Spree::Config.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

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

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

data/spec/mailers/test_mailer_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::TestMailer, type: :mailer do
+  let(:user) { create(:user) }
+
+  it "confirm_email accepts a user id as an alternative to a User object" do
+    Spree::TestMailer.test_email('test@example.com')
+  end
+end