solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/inventory_unit_spec.rb

@@ -0,0 +1,312 @@
+# 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
+        # We don't care about this in this test
+        allow(shipment).to receive(:ensure_correct_adjustment)
+        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
+      Spree::InventoryUnit.finalize_units!(inventory_units)
+      expect(inventory_units.any?(&:pending)).to be false
+    end
+  end
+
+  describe "#current_or_new_return_item" do
+    before { allow(inventory_unit).to receive_messages(total_excluding_vat: 100.0) }
+
+    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

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

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

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

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

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