solidus_core 2.10.0 → 2.11.0

data/spec/models/spree/unit_cancel_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::UnitCancel do
-  let(:unit_cancel) { described_class.create!(inventory_unit: inventory_unit, reason: described_class::SHORT_SHIP) }
-  let(:inventory_unit) { create(:inventory_unit) }
-
-  describe '#adjust!' do
-    subject { unit_cancel.adjust! }
-
-    it "creates an adjustment with the correct attributes" do
-      expect { subject }.to change{ Spree::Adjustment.count }.by(1)
-
-      adjustment = Spree::Adjustment.last
-      expect(adjustment.adjustable).to eq inventory_unit.line_item
-      expect(adjustment.amount).to eq(-10.0)
-      expect(adjustment.order).to eq inventory_unit.order
-      expect(adjustment.label).to eq "Cancellation - Short Ship"
-      expect(adjustment).to be_eligible
-      expect(adjustment).to be_finalized
-    end
-
-    context "when an adjustment has already been created" do
-      before { unit_cancel.adjust! }
-
-      it "raises" do
-        expect { subject }.to raise_error("Adjustment is already created")
-      end
-    end
-  end
-
-  describe '#compute_amount' do
-    subject { unit_cancel.compute_amount(line_item) }
-
-    let(:line_item) { inventory_unit.line_item }
-    let!(:inventory_unit2) { create(:inventory_unit, line_item: inventory_unit.line_item) }
-
-    context "all inventory on the line item are not canceled" do
-      it "divides the line item total by the inventory units size" do
-        expect(subject).to eq(-5.0)
-      end
-    end
-
-    context "some inventory on the line item is canceled" do
-      before { inventory_unit2.cancel! }
-
-      it "divides the line item total by the uncanceled units size" do
-        expect(subject).to eq(-10.0)
-      end
-
-      it "raises an error if dividing by 0" do
-        inventory_unit.cancel!
-        expect { subject }.to raise_error ZeroDivisionError, "Line Item does not have any inventory units available to cancel"
-      end
-    end
-
-    context "it is called with a line item that doesnt belong to the inventory unit" do
-      let(:line_item) { create(:line_item) }
-
-      it "raises an error" do
-        expect { subject }.to raise_error RuntimeError, "Adjustable does not match line item"
-      end
-    end
-
-    context "multiple inventory units" do
-      let(:quantity) { 4 }
-      let(:order) { create(:order_with_line_items, line_items_attributes: [{ quantity: quantity }]) }
-      let(:line_item) { order.line_items.first }
-      let(:inventory_units) { line_item.inventory_units }
-
-      it "has the right amount of inventory units" do
-        expect(inventory_units.size).to eq quantity
-      end
-
-      it "properly creates adjustments for line_item" do
-        inventory_units.each do |inventory_unit|
-          described_class.create!(inventory_unit: inventory_unit, reason: described_class::SHORT_SHIP).adjust!
-          inventory_unit.cancel!
-        end
-        expect(line_item.reload.total.to_d).to eq(0)
-      end
-    end
-
-    context 'when line item has additional taxes' do
-      let(:world_zone) { create(:zone, :with_country) }
-      let(:tax_category) { create :tax_category }
-      let(:product) { create :product, tax_category: tax_category }
-      let!(:additional_tax_rate) do
-        create(
-          :tax_rate,
-          name: 'Additional tax',
-          tax_categories: [tax_category],
-          zone: world_zone,
-          included_in_price: false,
-          amount: 0.15
-        )
-      end
-      let(:shipping_category) { create :shipping_category }
-      let(:shipping_method) do
-        create :shipping_method,
-               cost: 8.00,
-               shipping_categories: [shipping_category],
-               tax_category: tax_category,
-               zones: [world_zone]
-      end
-      let(:shipping_address) { create :address, country_iso_code: world_zone.countries.first.iso }
-      let(:order) do
-        create(
-          :order_with_line_items,
-          ship_address: shipping_address,
-          line_items_attributes: [{ product: product }]
-        )
-      end
-      let(:line_item) { order.line_items.first }
-      let(:inventory_unit) { line_item.inventory_units.first }
-
-      before { order.recalculate }
-
-      it 'does not include line item additional taxes' do
-        expect(line_item.additional_tax_total).not_to eq 0
-        expect(subject).to eq(-5.0)
-      end
-    end
-  end
-end

data/spec/models/spree/user_last_url_storer/rules/authentication_rule_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::UserLastUrlStorer::Rules::AuthenticationRule do
-  describe '#match?' do
-    let(:login_path) { '/sign_in' }
-    let(:request) { double(fullpath: fullpath) }
-    let(:controller) do
-      double(
-        request: request,
-        spree_login_path: login_path,
-        controller_name: 'controller_double'
-      )
-    end
-
-    subject { described_class.match?(controller) }
-
-    context 'when the request full path is an authentication route' do
-      let!(:fullpath) { login_path }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when the request full path is not an authentication route' do
-      let!(:fullpath) { '/products/baseball-cap' }
-
-      it { is_expected.to be false }
-    end
-  end
-end

data/spec/models/spree/user_last_url_storer_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::UserLastUrlStorer do
-  subject { described_class.new(controller) }
-
-  let(:fullpath) { '/products/baseball-cap' }
-  let(:session) { {} }
-  let(:request) { double(fullpath: fullpath) }
-  let(:controller) do
-    instance_double(
-      ApplicationController,
-      request: request,
-      session: session,
-      controller_name: 'app_controller_double'
-    )
-  end
-
-  module CustomRule
-    def self.match?(_controller)
-      true
-    end
-  end
-
-  after :each do
-    described_class.rules.delete('CustomRule')
-  end
-
-  describe '::rules' do
-    it 'includes default rules' do
-      rule = Spree::UserLastUrlStorer::Rules::AuthenticationRule
-      expect(described_class.rules).to include(rule)
-    end
-
-    it 'can add new rules' do
-      described_class.rules << CustomRule
-      expect(described_class.rules).to include(CustomRule)
-    end
-  end
-
-  describe '#store_location' do
-    context 'when at least one rule matches' do
-      it 'does not set the path value into the session' do
-        described_class.rules << CustomRule
-        subject.store_location
-        expect(session[:spree_user_return_to]).to be_nil
-      end
-    end
-
-    context 'when no rule matches' do
-      it 'sets the path value into the session' do
-        described_class.rules << CustomRule
-        described_class.rules.delete('CustomRule')
-        subject.store_location
-        expect(session[:spree_user_return_to]).to eql fullpath
-      end
-    end
-  end
-end

data/spec/models/spree/user_spec.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::LegacyUser, type: :model do
-  context "#last_incomplete_order" do
-    let!(:user) { create(:user) }
-
-    it "excludes orders that are not frontend_viewable" do
-      create(:order, user: user, frontend_viewable: false)
-      expect(user.last_incomplete_spree_order).to eq nil
-    end
-
-    it "can include orders that are not frontend viewable" do
-      order = create(:order, user: user, frontend_viewable: false)
-      expect(user.last_incomplete_spree_order(only_frontend_viewable: false)).to eq order
-    end
-
-    it "can scope to a store" do
-      store = create(:store)
-      store_1_order = create(:order, user: user, store: store)
-      create(:order, user: user, store: create(:store))
-      expect(user.last_incomplete_spree_order(store: store)).to eq store_1_order
-    end
-
-    it "excludes completed orders" do
-      create(:completed_order_with_totals, user: user, created_by: user)
-      expect(user.last_incomplete_spree_order).to eq nil
-    end
-
-    it "excludes orders created prior to the user's last completed order" do
-      create(:order, user: user, created_by: user, created_at: 1.second.ago)
-      create(:completed_order_with_totals, user: user, created_by: user)
-      expect(user.last_incomplete_spree_order).to eq nil
-    end
-
-    context "with completable_order_created_cutoff set" do
-      before do
-        stub_spree_preferences(completable_order_created_cutoff_days: 1)
-      end
-
-      it "excludes orders updated outside of the cutoff date" do
-        create(:order, user: user, created_by: user, created_at: 3.days.ago, updated_at: 2.days.ago)
-        expect(user.last_incomplete_spree_order).to eq nil
-      end
-    end
-
-    context "with completable_order_created_cutoff set" do
-      before do
-        stub_spree_preferences(completable_order_updated_cutoff_days: 1)
-      end
-
-      it "excludes orders updated outside of the cutoff date" do
-        create(:order, user: user, created_by: user, created_at: 3.days.ago, updated_at: 2.days.ago)
-        expect(user.last_incomplete_spree_order).to eq nil
-      end
-    end
-
-    it "chooses the most recently created incomplete order" do
-      create(:order, user: user, created_at: 1.second.ago)
-      order_2 = create(:order, user: user)
-      expect(user.last_incomplete_spree_order).to eq order_2
-    end
-
-    context "persists order address" do
-      let(:bill_address) { create(:address) }
-      let(:ship_address) { create(:address) }
-      let(:order) { create(:order, user: user, bill_address: bill_address, ship_address: ship_address) }
-
-      it "doesn't create new addresses" do
-        user.user_addresses.create(address: bill_address)
-        user.user_addresses.create(address: ship_address)
-        user.reload
-
-        expect {
-          user.persist_order_address(order)
-        }.not_to change { Spree::Address.count }
-      end
-
-      it "associates both the bill and ship address to the user" do
-        user.persist_order_address(order)
-        user.save!
-        user.user_addresses.reload
-
-        expect(user.user_addresses.find_first_by_address_values(order.bill_address.attributes)).to_not be_nil
-        expect(user.user_addresses.find_first_by_address_values(order.ship_address.attributes)).to_not be_nil
-      end
-    end
-
-    context "payment source" do
-      let(:payment_method) { create(:credit_card_payment_method) }
-      let!(:cc) do
-        create(:credit_card, user_id: user.id, payment_method: payment_method, gateway_customer_profile_id: "2342343")
-      end
-
-      it "has payment sources" do
-        Spree::Deprecation.silence do
-          expect(user.payment_sources.first.gateway_customer_profile_id).not_to be_empty
-        end
-      end
-    end
-  end
-end
-
-RSpec.describe Spree.user_class, type: :model do
-  context "reporting" do
-    let(:order_value) { BigDecimal("80.94") }
-    let(:order_count) { 4 }
-    let(:orders) { Array.new(order_count, double(total: order_value)) }
-
-    before do
-      allow(orders).to receive(:pluck).with(:total).and_return(orders.map(&:total))
-      allow(orders).to receive(:count).and_return(orders.length)
-    end
-
-    def load_orders
-      allow(subject).to receive(:spree_orders).and_return(double(complete: orders))
-    end
-
-    describe "#lifetime_value" do
-      context "with orders" do
-        before { load_orders }
-        it "returns the total of completed orders for the user" do
-          expect(subject.lifetime_value).to eq(order_count * order_value)
-        end
-      end
-      context "without orders" do
-        it "returns 0.00" do
-          expect(subject.lifetime_value).to eq BigDecimal("0.00")
-        end
-      end
-    end
-
-    describe "#display_lifetime_value" do
-      it "returns a Spree::Money version of lifetime_value" do
-        value = BigDecimal("500.05")
-        allow(subject).to receive(:lifetime_value).and_return(value)
-        expect(subject.display_lifetime_value).to eq Spree::Money.new(value)
-      end
-    end
-
-    describe "#order_count" do
-      before { load_orders }
-      it "returns the count of completed orders for the user" do
-        expect(subject.order_count).to eq order_count
-      end
-    end
-
-    describe "#average_order_value" do
-      context "with orders" do
-        before { load_orders }
-        it "returns the average completed order price for the user" do
-          expect(subject.average_order_value).to eq order_value
-        end
-      end
-      context "without orders" do
-        it "returns 0.00" do
-          expect(subject.average_order_value).to eq BigDecimal("0.00")
-        end
-      end
-    end
-
-    describe "#display_average_order_value" do
-      before { load_orders }
-      it "returns a Spree::Money version of average_order_value" do
-        value = BigDecimal("500.05")
-        allow(subject).to receive(:average_order_value).and_return(value)
-        expect(subject.display_average_order_value).to eq Spree::Money.new(value)
-      end
-    end
-  end
-
-  # TODO: Remove this after the method has been fully removed
-  describe "#total_available_store_credit" do
-    before do
-      allow_any_instance_of(Spree::LegacyUser).to receive(:total_available_store_credit).and_wrap_original do |method, *args|
-        Spree::Deprecation.silence do
-          method.call(*args)
-        end
-      end
-    end
-
-    context "user does not have any associated store credits" do
-      subject { create(:user) }
-
-      it "returns 0" do
-        expect(subject.total_available_store_credit).to be_zero
-      end
-    end
-
-    context "user has several associated store credits" do
-      let(:user)                     { create(:user) }
-      let(:amount)                   { 120.25 }
-      let(:additional_amount)        { 55.75 }
-      let(:store_credit)             { create(:store_credit, user: user, amount: amount, amount_used: 0.0) }
-      let!(:additional_store_credit) { create(:store_credit, user: user, amount: additional_amount, amount_used: 0.0) }
-
-      subject { store_credit.user }
-
-      context "part of the store credit has been used" do
-        let(:amount_used) { 35.00 }
-
-        before { store_credit.update(amount_used: amount_used) }
-
-        context "part of the store credit has been authorized" do
-          let(:authorized_amount) { 10 }
-
-          before { additional_store_credit.update(amount_authorized: authorized_amount) }
-
-          it "returns sum of amounts minus used amount and authorized amount" do
-            expect(subject.total_available_store_credit.to_f).to eq(amount + additional_amount - amount_used - authorized_amount)
-          end
-        end
-
-        context "there are no authorized amounts on any of the store credits" do
-          it "returns sum of amounts minus used amount" do
-            expect(subject.total_available_store_credit.to_f).to eq(amount + additional_amount - amount_used)
-          end
-        end
-      end
-
-      context "store credits have never been used" do
-        context "part of the store credit has been authorized" do
-          let(:authorized_amount) { 10 }
-
-          before { additional_store_credit.update(amount_authorized: authorized_amount) }
-
-          it "returns sum of amounts minus authorized amount" do
-            expect(subject.total_available_store_credit.to_f).to eq(amount + additional_amount - authorized_amount)
-          end
-        end
-
-        context "there are no authorized amounts on any of the store credits" do
-          it "returns sum of amounts" do
-            expect(subject.total_available_store_credit.to_f).to eq(amount + additional_amount)
-          end
-        end
-      end
-
-      context "all store credits have never been used or authorized" do
-        it "returns sum of amounts" do
-          expect(subject.total_available_store_credit.to_f).to eq(amount + additional_amount)
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/validations/db_maximum_length_validator_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Validations::DbMaximumLengthValidator, type: :model do
-  with_model 'LimitedProduct', scope: :all do
-    table do |t|
-      t.string :slug, limit: 255
-    end
-
-    model do
-      validates_with Spree::Validations::DbMaximumLengthValidator, field: :slug
-    end
-  end
-
-  let(:record) { LimitedProduct.new(slug: slug) }
-
-  context "when slug is below limit" do
-    let(:slug) { 'a' * 255 }
-    it 'should be valid' do
-      expect(record).to be_valid
-      expect(record.errors).to be_empty
-    end
-  end
-
-  context "when slug is too long" do
-    let(:slug) { 'a' * 256 }
-    it 'should be invalid and set error' do
-      expect(record).not_to be_valid
-      expect(record.errors[:slug]).to include(I18n.t("errors.messages.too_long", count: 255))
-    end
-  end
-end

data/spec/models/spree/variant/price_selector_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Variant::PriceSelector do
-  let(:variant) { build_stubbed(:variant) }
-
-  subject { described_class.new(variant) }
-
-  it { is_expected.to respond_to(:variant) }
-  it { is_expected.to respond_to(:price_for) }
-
-  describe ".pricing_options_class" do
-    it "returns the standard pricing options class" do
-      expect(described_class.pricing_options_class).to eq(Spree::Variant::PricingOptions)
-    end
-  end
-
-  describe "#price_for(options)" do
-    let(:variant) { create(:variant, price: 12.34) }
-
-    context "with the default currency" do
-      let(:pricing_options) { described_class.pricing_options_class.new(currency: "USD") }
-
-      it "returns the correct (default) price as a Spree::Money object" do
-        expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(12.34, currency: "USD"))
-      end
-
-      context "with the another country iso" do
-        let(:country) { create(:country, iso: "DE") }
-
-        let(:pricing_options) do
-          described_class.pricing_options_class.new(currency: "USD", country_iso: "DE")
-        end
-
-        context "with a price for that country present" do
-          before do
-            variant.prices.create(amount: 44.44, country: country, currency: Spree::Config.currency)
-          end
-
-          it "returns the correct price" do
-            expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(44.44, currency: "USD"))
-          end
-        end
-
-        context "with no price for that country present" do
-          context "and no fallback price for the variant present" do
-            before do
-              variant.prices.delete_all
-            end
-
-            it "returns nil" do
-              expect(subject.price_for(pricing_options)).to be_nil
-            end
-          end
-
-          context "and a fallback price for the variant present" do
-            before do
-              variant.prices.create(amount: 55.44, country: nil, currency: Spree::Config.currency)
-            end
-
-            it "returns the fallback price" do
-              expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(55.44, currency: "USD"))
-            end
-          end
-        end
-      end
-    end
-
-    context "with a different currency" do
-      let(:pricing_options) { described_class.pricing_options_class.new(currency: "EUR") }
-
-      context "when there is a price for that currency" do
-        before do
-          variant.prices.create(amount: 99.00, currency: "EUR")
-        end
-
-        it "returns the price in the correct currency as a Spree::Money object" do
-          expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(99.00, currency: "EUR"))
-        end
-      end
-
-      context "when there is no price for that currency" do
-        it "returns nil" do
-          expect(subject.price_for(pricing_options)).to be_nil
-        end
-      end
-    end
-  end
-end