solidus_core 2.10.2 → 2.11.0

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

data/spec/mailers/test_mailer_spec.rb

@@ -1,13 +0,0 @@
-# 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::Deprecation.silence do
-      Spree::TestMailer.test_email('test@example.com')
-    end
-  end
-end

data/spec/models/spree/ability_spec.rb

@@ -1,279 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-require 'cancan'
-require 'cancan/matchers'
-require 'spree/testing_support/ability_helpers'
-
-Spree::Deprecation.silence do
-  require 'spree/testing_support/bar_ability'
-end
-
-# Fake ability for testing registration of additional abilities
-class FooAbility
-  include CanCan::Ability
-
-  def initialize(_user)
-    # allow anyone to perform index on Order
-    can :index, Spree::Order
-    # allow anyone to update an Order with id of 1
-    can :update, Spree::Order do |order|
-      order.id == 1
-    end
-  end
-end
-
-RSpec.describe Spree::Ability, type: :model do
-  let(:user) { build(:user) }
-  let(:ability) { Spree::Ability.new(user) }
-  let(:token) { nil }
-
-  after(:each) {
-    Spree::Ability.abilities = Set.new
-  }
-
-  describe "#initialize" do
-    subject { Spree::Ability.new(user) }
-
-    it "activates permissions from the role configuration" do
-      expect(Spree::Config.roles).to receive(:activate_permissions!).
-        once
-
-      subject
-    end
-  end
-
-  context 'register_ability' do
-    it 'should add the ability to the list of abilties' do
-      Spree::Ability.register_ability(FooAbility)
-      expect(Spree::Ability.new(user).abilities).not_to be_empty
-    end
-
-    it 'should apply the registered abilities permissions' do
-      Spree::Ability.register_ability(FooAbility)
-      expect(Spree::Ability.new(user).can?(:update, mock_model(Spree::Order, user: nil, id: 1))).to be true
-    end
-  end
-
-  context 'for general resource' do
-    let(:resource) { Object.new }
-
-    context 'with admin user' do
-      let(:user) { create :admin_user }
-      it_should_behave_like 'access granted'
-      it_should_behave_like 'index allowed'
-    end
-
-    context 'with customer' do
-      it_should_behave_like 'access denied'
-      it_should_behave_like 'no index allowed'
-    end
-  end
-
-  context 'for admin protected resources' do
-    let(:resource) { Object.new }
-    let(:resource_shipment) { Spree::Shipment.new }
-    let(:resource_product) { Spree::Product.new }
-    let(:resource_user) { create :user }
-    let(:resource_order) { Spree::Order.new }
-    let(:fakedispatch_user) { Spree.user_class.create }
-    let(:fakedispatch_ability) { Spree::Ability.new(fakedispatch_user) }
-
-    context 'with admin user' do
-      it 'should be able to admin' do
-        user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
-        expect(ability).to be_able_to :admin, resource
-        expect(ability).to be_able_to :index, resource_order
-        expect(ability).to be_able_to :show, resource_product
-        expect(ability).to be_able_to :create, resource_user
-      end
-    end
-
-    context 'with fakedispatch user' do
-      it 'should be able to admin on the order and shipment pages' do
-        user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
-
-        Spree::Ability.register_ability(BarAbility)
-
-        expect(ability).not_to be_able_to :admin, resource
-
-        expect(ability).to be_able_to :admin, resource_order
-        expect(ability).to be_able_to :index, resource_order
-        expect(ability).not_to be_able_to :update, resource_order
-        # ability.should_not be_able_to :create, resource_order # Fails
-
-        expect(ability).to be_able_to :admin, resource_shipment
-        expect(ability).to be_able_to :index, resource_shipment
-        expect(ability).to be_able_to :create, resource_shipment
-
-        expect(ability).not_to be_able_to :admin, resource_product
-        expect(ability).not_to be_able_to :update, resource_product
-        # ability.should_not be_able_to :show, resource_product # Fails
-
-        expect(ability).not_to be_able_to :admin, resource_user
-        expect(ability).not_to be_able_to :update, resource_user
-        expect(ability).to be_able_to :update, user
-        # ability.should_not be_able_to :create, resource_user # Fails
-        # It can create new users if is has access to the :admin, User!!
-
-        # TODO: change the Ability class so only users and customers get the extra premissions?
-
-        Spree::Ability.remove_ability(BarAbility)
-      end
-    end
-
-    context 'with customer' do
-      it 'should not be able to admin' do
-        expect(ability).not_to be_able_to :admin, resource
-        expect(ability).not_to be_able_to :admin, resource_order
-        expect(ability).not_to be_able_to :admin, resource_product
-        expect(ability).not_to be_able_to :admin, resource_user
-      end
-    end
-  end
-
-  context 'as Guest User' do
-    context 'for Country' do
-      let(:resource) { Spree::Country.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for OptionType' do
-      let(:resource) { Spree::OptionType.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for OptionValue' do
-      let(:resource) { Spree::OptionType.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for Order' do
-      let(:resource) { Spree::Order.new }
-
-      context 'requested by same user' do
-        before(:each) { resource.user = user }
-        it_should_behave_like 'access granted'
-        it_should_behave_like 'no index allowed'
-      end
-
-      context 'requested by other user' do
-        before(:each) { resource.user = Spree.user_class.new }
-        it_should_behave_like 'create only'
-      end
-
-      context 'requested with proper token' do
-        let(:token) { 'TOKEN123' }
-        before(:each) { allow(resource).to receive_messages guest_token: 'TOKEN123' }
-        it_should_behave_like 'access granted'
-        it_should_behave_like 'no index allowed'
-      end
-
-      context 'requested with inproper token' do
-        let(:token) { 'FAIL' }
-        before(:each) { allow(resource).to receive_messages guest_token: 'TOKEN123' }
-        it_should_behave_like 'create only'
-      end
-    end
-
-    context 'for Product' do
-      let(:resource) { Spree::Product.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for ProductProperty' do
-      let(:resource) { Spree::Product.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for Property' do
-      let(:resource) { Spree::Product.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for State' do
-      let(:resource) { Spree::State.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for Stock Item' do
-      let(:resource) { Spree::StockItem.new }
-      context 'active stock location' do
-        before { resource.build_stock_location(active: true) }
-        it_should_behave_like 'read only'
-      end
-
-      context 'inactive stock location' do
-        before { resource.build_stock_location(active: false) }
-        it_should_behave_like 'access denied'
-      end
-    end
-
-    context 'for Stock Location' do
-      let(:resource) { Spree::StockLocation.new }
-      context 'active' do
-        before { resource.active = true }
-        it_should_behave_like 'read only'
-      end
-
-      context 'inactive' do
-        before { resource.active = false }
-        it_should_behave_like 'access denied'
-      end
-    end
-
-    context 'for Taxons' do
-      let(:resource) { Spree::Taxon.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for Taxonomy' do
-      let(:resource) { Spree::Taxonomy.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for User' do
-      context 'requested by same user' do
-        let(:resource) { user }
-        it_should_behave_like 'access granted'
-        it_should_behave_like 'no index allowed'
-      end
-      context 'requested by other user' do
-        let(:resource) { Spree.user_class.create }
-        it_should_behave_like 'create only'
-      end
-    end
-
-    context 'for Variant' do
-      let(:resource) { Spree::Variant.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-
-    context 'for Zone' do
-      let(:resource) { Spree::Zone.new }
-      context 'requested by any user' do
-        it_should_behave_like 'read only'
-      end
-    end
-  end
-end