solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/inventory_unit_spec.rb

@@ -1,309 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::InventoryUnit, type: :model do
-  let(:stock_location) { create(:stock_location_with_items) }
-  let(:stock_item) { stock_location.stock_items.order(:id).first }
-  let(:line_item) { create(:line_item, variant: stock_item.variant) }
-
-  describe ".cancelable" do
-    let!(:pending_unit) { create(:inventory_unit, pending: true) }
-    let!(:non_pending_unit) { create(:inventory_unit, pending: false) }
-
-    subject { described_class.cancelable }
-
-    it { is_expected.to contain_exactly(non_pending_unit) }
-  end
-
-  context "#backordered_for_stock_item" do
-    let(:order) do
-      order = create(:order, state: 'complete', ship_address: create(:ship_address))
-      order.completed_at = Time.current
-      create(:shipment, order: order, stock_location: stock_location)
-      order.shipments.reload
-      create(:line_item, order: order, variant: stock_item.variant)
-      order.line_items.reload
-      order.tap(&:save!)
-    end
-
-    let(:shipment) do
-      order.shipments.first
-    end
-
-    let(:shipping_method) do
-      shipment.shipping_methods.first
-    end
-
-    let!(:unit) do
-      unit = shipment.inventory_units.first
-      unit.state = 'backordered'
-      unit.variant_id = stock_item.variant.id
-      unit.line_item = line_item
-      unit.tap(&:save!)
-    end
-
-    before do
-      stock_item.set_count_on_hand(-2)
-    end
-
-    # Regression for https://github.com/spree/spree/issues/3066
-    it "returns modifiable objects" do
-      units = Spree::InventoryUnit.backordered_for_stock_item(stock_item)
-      units.first.save!
-    end
-
-    it "finds inventory units from its stock location when the unit's variant matches the stock item's variant" do
-      expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).to match_array([unit])
-    end
-
-    it "does not find inventory units that aren't backordered" do
-      on_hand_unit = shipment.inventory_units.build
-      on_hand_unit.state = 'on_hand'
-      on_hand_unit.line_item = line_item
-      on_hand_unit.variant = stock_item.variant
-      on_hand_unit.save!
-
-      expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).not_to include(on_hand_unit)
-    end
-
-    it "does not find inventory units that don't match the stock item's variant" do
-      other_variant_unit = shipment.inventory_units.build
-      other_variant_unit.state = 'backordered'
-      other_variant_unit.line_item = line_item
-      other_variant_unit.variant = create(:variant)
-      other_variant_unit.save!
-
-      expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).not_to include(other_variant_unit)
-    end
-
-    it "does not change shipping cost when fulfilling the order" do
-      current_shipment_cost = shipment.cost
-      shipping_method.calculator.set_preference(:amount, current_shipment_cost + 5.0)
-      stock_item.set_count_on_hand(0)
-      expect(shipment.reload.cost).to eq(current_shipment_cost)
-    end
-
-    context "other shipments" do
-      let(:other_order) do
-        order = create(:order)
-        order.state = 'payment'
-        order.completed_at = nil
-        order.tap(&:save!)
-      end
-
-      let(:other_shipment) do
-        shipment = Spree::Shipment.new
-        shipment.stock_location = stock_location
-        shipment.shipping_methods << create(:shipping_method)
-        shipment.order = other_order
-        shipment.tap(&:save!)
-      end
-
-      let!(:other_unit) do
-        unit = other_shipment.inventory_units.build
-        unit.state = 'backordered'
-        unit.variant_id = stock_item.variant.id
-        unit.line_item = line_item
-        unit.tap(&:save!)
-      end
-
-      it "does not find inventory units belonging to incomplete orders" do
-        expect(Spree::InventoryUnit.backordered_for_stock_item(stock_item)).not_to include(other_unit)
-      end
-    end
-  end
-
-  context "variants discarded" do
-    let!(:unit) { create(:inventory_unit) }
-
-    it "can still fetch variant" do
-      unit.variant.discard
-      expect(unit.reload.variant).to be_a Spree::Variant
-    end
-
-    it "can still fetch variants by eager loading (remove default_scope)" do
-      skip "find a way to remove default scope when eager loading associations"
-      unit.variant.discard
-      expect(Spree::InventoryUnit.joins(:variant).includes(:variant).first.variant).to be_a Spree::Variant
-    end
-  end
-
-  context "#finalize_units!" do
-    let!(:stock_location) { create(:stock_location) }
-    let(:variant) { create(:variant) }
-    let(:inventory_units) {
-      [
-      create(:inventory_unit, variant: variant),
-      create(:inventory_unit, variant: variant)
-    ]
-    }
-
-    it "should create a stock movement" do
-      expect(Spree::Deprecation).to receive(:warn)
-      Spree::InventoryUnit.finalize_units!(inventory_units)
-      expect(inventory_units.any?(&:pending)).to be false
-    end
-  end
-
-  describe "#current_or_new_return_item" do
-    subject { inventory_unit.current_or_new_return_item }
-
-    context "associated with a return item" do
-      let(:return_item) { create(:return_item) }
-      let(:inventory_unit) { return_item.inventory_unit }
-
-      it "returns a persisted return item" do
-        expect(subject).to be_persisted
-      end
-
-      it "returns it's associated return_item" do
-        expect(subject).to eq return_item
-      end
-    end
-
-    context "no associated return item" do
-      let(:inventory_unit) { create(:inventory_unit) }
-
-      it "returns a new return item" do
-        expect(subject).to_not be_persisted
-      end
-
-      it "associates itself to the new return_item" do
-        expect(subject.inventory_unit).to eq inventory_unit
-      end
-    end
-  end
-
-  describe '#additional_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_additional_tax_total) { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        additional_tax_total: line_item_additional_tax_total
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.additional_tax_total).to eq line_item_additional_tax_total / quantity
-    end
-  end
-
-  describe '#included_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_included_tax_total) { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        included_tax_total: line_item_included_tax_total
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.included_tax_total).to eq line_item_included_tax_total / quantity
-    end
-  end
-
-  describe '#additional_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_additional_tax_total) { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        additional_tax_total: line_item_additional_tax_total
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.additional_tax_total).to eq line_item_additional_tax_total / quantity
-    end
-  end
-
-  describe '#included_tax_total' do
-    let(:quantity) { 2 }
-    let(:line_item_included_tax_total) { 10.00 }
-    let(:line_item) do
-      build(:line_item, {
-        quantity: quantity,
-        included_tax_total: line_item_included_tax_total
-      })
-    end
-
-    subject do
-      build(:inventory_unit, line_item: line_item)
-    end
-
-    it 'is the correct amount' do
-      expect(subject.included_tax_total).to eq line_item_included_tax_total / quantity
-    end
-  end
-
-  describe "#exchange_requested?" do
-    subject { inventory_unit.exchange_requested? }
-
-    context "return item contains inventory unit and was for an exchange" do
-      let(:exchange_return_item) { create(:exchange_return_item) }
-      let(:inventory_unit) { exchange_return_item.inventory_unit }
-      it { is_expected.to eq true }
-    end
-
-    context "return item does not contain inventory unit" do
-      let(:inventory_unit) { create(:inventory_unit) }
-      it { is_expected.to eq false }
-    end
-  end
-
-  context "destroy prevention" do
-    it "can be destroyed when on hand" do
-      inventory_unit = create(:inventory_unit, state: "on_hand")
-      expect(inventory_unit.destroy).to be_truthy
-      expect { inventory_unit.reload }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "can be destroyed when backordered" do
-      inventory_unit = create(:inventory_unit, state: "backordered")
-      expect(inventory_unit.destroy).to be_truthy
-      expect { inventory_unit.reload }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "cannot be destroyed when shipped" do
-      inventory_unit = create(:inventory_unit, state: "shipped")
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-
-    it "cannot be destroyed when returned" do
-      inventory_unit = create(:inventory_unit, state: "returned")
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-
-    it "can be destroyed if its shipment is ready" do
-      inventory_unit = create(:order_ready_to_ship).inventory_units.first
-      expect(inventory_unit.destroy).to be_truthy
-      expect { inventory_unit.reload }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "cannot be destroyed if its shipment is shipped" do
-      inventory_unit = create(:shipped_order).inventory_units.first
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
-    end
-  end
-end

data/spec/models/spree/line_item_spec.rb

@@ -1,240 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::LineItem, type: :model do
-  let(:order) { create :order_with_line_items, line_items_count: 1 }
-  let(:line_item) { order.line_items.first }
-
-  context '#destroy' do
-    it "fetches soft-deleted products" do
-      line_item.product.discard
-      expect(line_item.reload.product).to be_a Spree::Product
-    end
-
-    it "fetches soft-deleted variants" do
-      line_item.variant.discard
-      expect(line_item.reload.variant).to be_a Spree::Variant
-    end
-
-    it "returns inventory when a line item is destroyed" do
-      expect_any_instance_of(Spree::OrderInventory).to receive(:verify)
-      line_item.destroy
-    end
-
-    it "deletes inventory units" do
-      expect { line_item.destroy }.to change { line_item.inventory_units.count }.from(1).to(0)
-    end
-  end
-
-  context "#save" do
-    context "target_shipment is provided" do
-      it "verifies inventory" do
-        line_item.target_shipment = Spree::Shipment.new
-        expect_any_instance_of(Spree::OrderInventory).to receive(:verify)
-        line_item.save
-      end
-    end
-  end
-
-  describe 'line item creation' do
-    let(:variant) { create :variant }
-
-    subject(:line_item) { Spree::LineItem.new(variant: variant, order: order) }
-
-    # Tests for https://github.com/spree/spree/issues/3391
-    context 'before validation' do
-      before { line_item.valid? }
-
-      it 'copies the variants price' do
-        expect(line_item.price).to eq(variant.price)
-      end
-
-      it 'copies the variants cost_price' do
-        expect(line_item.cost_price).to eq(variant.cost_price)
-      end
-
-      it "copies the order's currency" do
-        expect(line_item.currency).to eq(order.currency)
-      end
-
-      # Test for https://github.com/spree/spree/issues/3481
-      it 'copies the variants tax category' do
-        expect(line_item.tax_category).to eq(line_item.variant.tax_category)
-      end
-    end
-
-    # Specs for https://github.com/solidusio/solidus/pull/522#issuecomment-170668125
-    context "with `#copy_price` defined" do
-      before(:context) do
-        Spree::LineItem.class_eval do
-          def copy_price
-            self.cost_price = 10
-            self.price = 20
-          end
-        end
-      end
-
-      after(:context) do
-        Spree::LineItem.class_eval do
-          remove_method :copy_price
-        end
-      end
-
-      it 'should display a deprecation warning' do
-        expect(Spree::Deprecation).to receive(:warn)
-        Spree::LineItem.new(variant: variant, order: order)
-      end
-
-      it 'should run the user-defined copy_price method' do
-        expect_any_instance_of(Spree::LineItem).to receive(:copy_price).and_call_original
-        Spree::Deprecation.silence do
-          Spree::LineItem.new(variant: variant, order: order)
-        end
-      end
-    end
-  end
-
-  # TODO: Remove this spec after the method has been removed.
-  describe '#discounted_amount' do
-    it "returns the amount minus any discounts" do
-      line_item.price = 10
-      line_item.quantity = 2
-      line_item.promo_total = -5
-      expect(Spree::Deprecation.silence { line_item.discounted_amount }).to eq(15)
-    end
-  end
-
-  # TODO: Remove this spec after the method has been removed.
-  describe "#discounted_money" do
-    it "should return a money object with the discounted amount" do
-      expect(Spree::Deprecation.silence { line_item.discounted_amount }).to eq(10.00)
-      expect(Spree::Deprecation.silence { line_item.discounted_money.to_s }).to eq "$10.00"
-    end
-  end
-
-  describe '#total_before_tax' do
-    before do
-      line_item.update!(price: 10, quantity: 2)
-    end
-    let!(:admin_adjustment) { create(:adjustment, adjustable: line_item, order: line_item.order, amount: -1, source: nil) }
-    let!(:promo_adjustment) { create(:adjustment, adjustable: line_item, order: line_item.order, amount: -2, source: promo_action) }
-    let!(:ineligible_promo_adjustment) { create(:adjustment, eligible: false, adjustable: line_item, order: line_item.order, amount: -4, source: promo_action) }
-    let(:promo_action) { promo.actions[0] }
-    let(:promo) { create(:promotion, :with_line_item_adjustment) }
-
-    it 'returns the amount minus any adjustments' do
-      expect(line_item.total_before_tax).to eq(20 - 1 - 2)
-    end
-  end
-
-  describe ".money" do
-    before do
-      line_item.price = 3.50
-      line_item.quantity = 2
-    end
-
-    it "returns a Spree::Money representing the total for this line item" do
-      expect(line_item.money.to_s).to eq("$7.00")
-    end
-  end
-
-  describe '.single_money' do
-    before { line_item.price = 3.50 }
-    it "returns a Spree::Money representing the price for one variant" do
-      expect(line_item.single_money.to_s).to eq("$3.50")
-    end
-  end
-
-  context 'setting a line item price' do
-    let(:store) { create(:store, default: true) }
-    let(:order) { Spree::Order.new(currency: "RUB", store: store) }
-    let(:variant) { Spree::Variant.new(product: Spree::Product.new) }
-    let(:line_item) { Spree::LineItem.new(order: order, variant: variant) }
-
-    before { expect(variant).to receive(:price_for).at_least(:once).and_return(price) }
-
-    context "when a price exists in order currency" do
-      let(:price) { Spree::Money.new(99.00, currency: "RUB") }
-
-      it "is a valid line item" do
-        expect(line_item.valid?).to be_truthy
-        expect(line_item.errors[:price].size).to eq(0)
-      end
-    end
-
-    context "when a price does not exist in order currency" do
-      let(:price) { nil }
-
-      it "is not a valid line item" do
-        expect(line_item.valid?).to be_falsey
-        expect(line_item.errors[:price].size).to eq(1)
-      end
-    end
-  end
-
-  describe "#options=" do
-    let(:options) { { price: 123, quantity: 5 } }
-
-    it "updates the data provided in the options" do
-      line_item.options = options
-
-      expect(line_item.price).to eq 123
-      expect(line_item.quantity).to eq 5
-    end
-
-    context "when price is not provided" do
-      let(:options) { { quantity: 5 } }
-
-      it "sets price anyway, retrieving it from line item options" do
-        expect(line_item.variant)
-          .to receive(:price_for)
-          .and_return(Spree::Money.new(123, currency: "USD"))
-
-        line_item.options = options
-
-        expect(line_item.price).to eq 123
-        expect(line_item.quantity).to eq 5
-      end
-    end
-  end
-
-  describe 'money_price=' do
-    let(:currency) { "USD" }
-    let(:new_price) { Spree::Money.new(99.00, currency: currency) }
-
-    it 'assigns a new price' do
-      line_item.money_price = new_price
-      expect(line_item.price).to eq(new_price.cents / 100.0)
-    end
-
-    context 'when the new price is nil' do
-      let(:new_price) { nil }
-
-      it 'makes the line item price empty' do
-        line_item.money_price = new_price
-        expect(line_item.price).to be_nil
-      end
-    end
-
-    context 'when the price has a currency different from the order currency' do
-      let(:currency) { "RUB" }
-
-      it 'raises an exception' do
-        expect {
-          line_item.money_price = new_price
-        }.to raise_exception Spree::LineItem::CurrencyMismatch
-      end
-    end
-  end
-
-  describe "#pricing_options" do
-    subject { line_item.pricing_options }
-
-    it { is_expected.to be_a(Spree::Config.pricing_options_class) }
-
-    it "holds the order currency" do
-      expect(subject.currency).to eq("USD")
-    end
-  end
-end

data/spec/models/spree/option_type_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OptionType, type: :model do
-  context "touching" do
-    it "should touch a product" do
-      product_option_type = create(:product_option_type)
-      option_type = product_option_type.option_type
-      product = product_option_type.product
-      product.update_column(:updated_at, 1.day.ago)
-      option_type.touch
-      expect(product.reload.updated_at).to be_within(3.seconds).of(Time.current)
-    end
-  end
-end

data/spec/models/spree/option_value_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OptionValue, type: :model do
-  include ActiveSupport::Testing::TimeHelpers
-
-  context "touching" do
-    let!(:variant) do
-      travel_to(1.day.ago) do
-        create(:variant)
-      end
-    end
-    let(:option_value) { variant.option_values.first }
-
-    it "should touch a variant" do
-      now = Time.current
-      travel_to(now) do
-        option_value.touch
-        expect(variant.reload.updated_at).to be_within(1.second).of(now)
-      end
-    end
-
-    context "from the after_save hook" do
-      it "should not touch the variant if there are no changes" do
-        now = Time.current
-        travel_to(now) do
-          option_value.save!
-          expect(variant.reload.updated_at).to be <= 1.day.ago
-        end
-      end
-
-      it "should touch the variant if there are changes" do
-        now = Time.current
-        travel_to(now) do
-          option_value.name += "--1"
-          option_value.save!
-          expect(variant.reload.updated_at).to be_within(1.second).of(now)
-        end
-      end
-    end
-  end
-
-  describe "#presentation_with_option_type" do
-    let(:option_value) { build(:option_value) }
-    subject { option_value.presentation_with_option_type }
-
-    it "returns a string in the correct form" do
-      expect(subject).to eq "Size - S"
-    end
-  end
-end

data/spec/models/spree/order/address_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Order, type: :model do
-  let(:order) { Spree::Order.new }
-
-  context 'validation' do
-    context "when @use_billing is populated" do
-      before do
-        order.bill_address = stub_model(Spree::Address)
-        order.ship_address = nil
-      end
-
-      context "with true" do
-        before { order.use_billing = true }
-
-        it "clones the bill address to the ship address" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with 'true'" do
-        before { order.use_billing = 'true' }
-
-        it "clones the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with '1'" do
-        before { order.use_billing = '1' }
-
-        it "clones the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with something other than a 'truthful' value" do
-        before { order.use_billing = '0' }
-
-        it "does not clone the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/order/adjustments_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Order do
-  context "when an order has an adjustment that zeroes the total, but another adjustment for shipping that raises it above zero" do
-    let!(:persisted_order) { create(:order) }
-    let!(:line_item) { create(:line_item) }
-    let!(:shipping_method) do
-      sm = create(:shipping_method)
-      sm.calculator.preferred_amount = 10
-      sm.save
-      sm
-    end
-
-    before do
-      persisted_order.line_items << line_item
-      create(:adjustment, amount: -line_item.amount, label: "Promotion", adjustable: line_item, order: persisted_order)
-      persisted_order.state = 'delivery'
-      persisted_order.save # To ensure new state_change event
-    end
-
-    it "transitions from delivery to payment" do
-      allow(persisted_order).to receive_messages(payment_required?: true)
-      persisted_order.next!
-      expect(persisted_order.state).to eq("payment")
-    end
-  end
-end