spree_core 3.1.14 → 3.2.0.rc1

data/spec/models/spree/gateway/bogus_simple.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Spree::Gateway::BogusSimple, type: :model do
+
+  subject { Spree::Gateway::BogusSimple.new }
+
+  # regression test for #3824
+  describe "#capture" do
+    it "returns success with the right response code" do
+      response = subject.capture(123, '12345', {})
+      expect(response.message).to include("success")
+    end
+
+    it "returns failure with the wrong response code" do
+      response = subject.capture(123, 'wrong', {})
+      expect(response.message).to include("failure")
+    end
+  end
+
+end

data/spec/models/spree/gateway/bogus_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Spree
+  describe Gateway::Bogus, type: :model do
+    let(:bogus) { create(:credit_card_payment_method) }
+    let!(:cc) { create(:credit_card, payment_method: bogus, gateway_customer_profile_id: "BGS-RERTERT") }
+
+    it "disable recurring contract by destroying payment source" do
+      bogus.disable_customer_profile(cc)
+      expect(cc.gateway_customer_profile_id).to be_nil
+    end
+  end
+end

data/spec/models/spree/gateway_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Spree::Gateway, type: :model do
+  class Provider
+    def initialize(options)
+    end
+
+    def imaginary_method
+
+    end
+  end
+
+  class TestGateway < Spree::Gateway
+    def provider_class
+      Provider
+    end
+  end
+
+  it "passes through all arguments on a method_missing call" do
+    gateway = TestGateway.new
+    expect(gateway.provider).to receive(:imaginary_method).with('foo')
+    gateway.imaginary_method('foo')
+  end
+
+  context "fetching payment sources" do
+    let(:order) { Spree::Order.create(user_id: 1) }
+
+    let(:has_card) { create(:credit_card_payment_method) }
+    let(:no_card) { create(:credit_card_payment_method) }
+
+    let(:cc) do
+      create(:credit_card, payment_method: has_card, gateway_customer_profile_id: "EFWE")
+    end
+
+    let(:payment) do
+      create(:payment, order: order, source: cc, payment_method: has_card)
+    end
+
+    it "finds credit cards associated on a order completed" do
+      allow(payment.order).to receive_messages completed?: true
+
+      expect(no_card.reusable_sources(payment.order)).to be_empty
+      expect(has_card.reusable_sources(payment.order)).not_to be_empty
+    end
+
+    it "finds credit cards associated with the order user" do
+      cc.update_column :user_id, 1
+      allow(payment.order).to receive_messages completed?: false
+
+      expect(no_card.reusable_sources(payment.order)).to be_empty
+      expect(has_card.reusable_sources(payment.order)).not_to be_empty
+    end
+  end
+
+  it "returns exchange multiplier for gateway" do
+    gateway = TestGateway.new
+
+    rate = Spree::Gateway::FROM_DOLLAR_TO_CENT_RATE
+    expect(gateway.exchange_multiplier).to eq rate
+  end
+end

data/spec/models/spree/image_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Spree::Image, type: :model do
+
+  describe 'callbacks' do
+    it { is_expected.to callback(:find_dimensions).before(:save).if(:attachment_updated_at_changed?) }
+  end
+end

data/spec/models/spree/inventory_unit_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+describe Spree::InventoryUnit, type: :model do
+  let(:stock_location) { create(:stock_location_with_items) }
+  let(:stock_item) { stock_location.stock_items.order(:id).first }
+
+  describe 'scopes' do
+    let!(:inventory_unit_1) { create(:inventory_unit, state: 'on_hand') }
+    let!(:inventory_unit_2) { create(:inventory_unit, state: 'backordered') }
+    let!(:inventory_unit_3) { create(:inventory_unit, state: 'shipped') }
+    let!(:inventory_unit_4) { create(:inventory_unit, state: 'returned') }
+
+    describe '.backordered' do
+      it { expect(Spree::InventoryUnit.backordered).to eq([inventory_unit_2]) }
+    end
+
+    describe '.on_hand' do
+      it { expect(Spree::InventoryUnit.on_hand).to eq([inventory_unit_1]) }
+    end
+
+    describe '.on_hand_or_backordered' do
+      it { expect(Spree::InventoryUnit.on_hand_or_backordered).to match_array([inventory_unit_1, inventory_unit_2]) }
+    end
+
+    describe '.shipped' do
+      it { expect(Spree::InventoryUnit.shipped).to eq([inventory_unit_3]) }
+    end
+
+    describe '.returned' do
+      it { expect(Spree::InventoryUnit.returned).to eq([inventory_unit_4]) }
+    end
+  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.tap(&:save!)
+    end
+
+    before do
+      stock_item.set_count_on_hand(-2)
+    end
+
+    # Regression for #3066
+    it "returns modifiable objects" do
+      units = Spree::InventoryUnit.backordered_for_stock_item(stock_item)
+      expect { units.first.save! }.to_not raise_error
+    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.variant_id = 1
+      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.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.order_id = other_order.id
+        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 "#finalize_units!" do
+    let!(:stock_location) { create(:stock_location) }
+    let(:variant) { create(:variant) }
+    let (:shipment) { create(:shipment) }
+    let(:inventory_units) { [
+      create(:inventory_unit, variant: variant),
+      create(:inventory_unit, variant: variant)
+    ] }
+    before do
+      shipment.inventory_units = inventory_units
+    end
+
+    it "should create a stock movement" do
+      expect { shipment.inventory_units.finalize_units! }.
+        to change { shipment.inventory_units.where(pending: false).count }.by 2
+    end
+  end
+
+  describe "#current_or_new_return_item" do
+    before { allow(inventory_unit).to receive_messages(pre_tax_amount: 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
+end

data/spec/models/spree/line_item_spec.rb

@@ -0,0 +1,346 @@
+require 'spec_helper'
+
+describe Spree::LineItem, type: :model do
+  let(:order) { create :order_with_line_items, line_items_count: 1 }
+  let(:line_item) { order.line_items.first }
+
+  before { create(:store) }
+
+  describe 'Validations' do
+    it { expect(line_item).to validate_numericality_of(:quantity).only_integer.with_message(Spree.t('validation.must_be_int')) }
+    it { expect(line_item).to validate_presence_of(:order) }
+
+    describe 'ensure_proper_currency' do
+      context 'order is present' do
+        context "when line_item's currency matches with order's" do
+          it { expect(line_item).to be_valid }
+        end
+
+        context "when line_item's currency does not matches with order's" do
+          before do
+            line_item.currency = "Invalid Currency"
+          end
+
+          it { expect(line_item).not_to be_valid }
+        end
+      end
+    end
+  end
+
+  describe '#ensure_valid_quantity' do
+    context 'quantity.nil?' do
+      before do
+        line_item.quantity = nil
+        line_item.valid?
+      end
+
+      it { expect(line_item.quantity).to be_zero }
+    end
+
+    context 'quantity < 0' do
+      before do
+        line_item.quantity = -1
+        line_item.valid?
+      end
+
+      it { expect(line_item.quantity).to be_zero }
+    end
+
+    context 'quantity = 0' do
+      before do
+        line_item.quantity = 0
+        line_item.valid?
+      end
+
+      it { expect(line_item.quantity).to be_zero }
+    end
+
+    context 'quantity > 0' do
+      let(:original_quantity) { 1 }
+
+      before do
+        line_item.quantity = original_quantity
+        line_item.valid?
+      end
+
+      it { expect(line_item.quantity).to eq(original_quantity) }
+    end
+  end
+
+  context '#save' do
+    it 'touches the order' do
+      expect(line_item.order).to receive(:touch)
+      line_item.touch
+    end
+  end
+
+  context "#discontinued" do
+    it "fetches discontinued products" do
+      line_item.product.discontinue!
+      expect(line_item.reload.product).to be_a Spree::Product
+    end
+
+    it "fetches discontinued variants" do
+      line_item.variant.discontinue!
+      expect(line_item.reload.variant).to be_a Spree::Variant
+    end
+  end
+
+  context "#destroy" do
+    let!(:line_item) { order.line_items.first }
+    it "returns inventory when a line item is destroyed" do
+      is_expected.to callback(:verify_order_inventory).before(: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 "line item changes" do
+      before do
+        line_item.quantity = line_item.quantity + 1
+      end
+
+      it "triggers adjustment total recalculation" do
+        expect(line_item).to receive(:update_tax_charge) # Regression test for https://github.com/spree/spree/issues/4671
+        expect(line_item).to receive(:recalculate_adjustments)
+        line_item.save
+      end
+    end
+
+    context "line item does not change" do
+      it "does not trigger adjustment total recalculation" do
+        expect(line_item).not_to receive(:recalculate_adjustments)
+        line_item.save
+      end
+    end
+
+    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
+
+  context "#create" do
+    let(:variant) { create(:variant) }
+
+    before do
+      create(:tax_rate, zone: order.tax_zone, tax_category: variant.tax_category)
+    end
+
+    context "when order has a tax zone" do
+      before do
+        expect(order.tax_zone).to be_present
+      end
+
+      it "creates a tax adjustment" do
+        order.contents.add(variant)
+        line_item = order.find_line_item_by_variant(variant)
+        expect(line_item.adjustments.tax.count).to eq(1)
+      end
+    end
+
+    context "when order does not have a tax zone" do
+      before do
+        order.bill_address = nil
+        order.ship_address = nil
+        order.save
+        expect(order.reload.tax_zone).to be_nil
+      end
+
+      it "does not create a tax adjustment" do
+        order.contents.add(variant)
+        line_item = order.find_line_item_by_variant(variant)
+        expect(line_item.adjustments.tax.count).to eq(0)
+      end
+    end
+  end
+
+  # Test for #3391
+  context '#copy_price' do
+    it "copies over a variant's prices" do
+      line_item.price = nil
+      line_item.cost_price = nil
+      line_item.currency = nil
+      line_item.copy_price
+      variant = line_item.variant
+      expect(line_item.price).to eq(variant.price)
+      expect(line_item.cost_price).to eq(variant.cost_price)
+      expect(line_item.currency).to eq(variant.currency)
+    end
+  end
+
+  # test for copying prices when the vat changes
+  context "#update_price" do
+    it "copies over a variants differing price for another vat zone" do
+      expect(line_item.variant).to receive(:price_including_vat_for).and_return(12)
+      line_item.price = 10
+      line_item.update_price
+      expect(line_item.price).to eq(12)
+    end
+  end
+
+  # Test for #3481
+  context '#copy_tax_category' do
+    it "copies over a variant's tax category" do
+      line_item.tax_category = nil
+      line_item.copy_tax_category
+      expect(line_item.tax_category).to eq(line_item.variant.tax_category)
+    end
+  end
+
+  describe '#discounted_amount' do
+    it "returns the amount minus any discounts" do
+      line_item.price = 10
+      line_item.quantity = 2
+      line_item.taxable_adjustment_total = -5
+      expect(line_item.discounted_amount).to eq(15)
+    end
+  end
+
+  describe '.currency' do
+    it 'returns the globally configured currency' do
+      line_item.currency == 'USD'
+    end
+  end
+
+  describe "#discounted_money" do
+    it "should return a money object with the discounted amount" do
+      expect(line_item.discounted_money.to_s).to eq "$10.00"
+    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 do
+      line_item.price = 3.50
+      line_item.quantity = 2
+    end
+
+    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 "has inventory (completed order so items were already unstocked)" do
+    let(:order) { Spree::Order.create(email: 'spree@example.com') }
+    let(:variant) { create(:variant) }
+
+    context "nothing left on stock" do
+      before do
+        variant.stock_items.update_all count_on_hand: 5, backorderable: false
+        order.contents.add(variant, 5)
+        order.create_proposed_shipments
+        order.finalize!
+      end
+
+      it "allows to decrease item quantity" do
+        line_item = order.line_items.first
+        line_item.quantity -= 1
+        line_item.target_shipment = order.shipments.first
+
+        line_item.save
+        expect(line_item.errors_on(:quantity).size).to eq(0)
+      end
+
+      it "doesnt allow to increase item quantity" do
+        line_item = order.line_items.first
+        line_item.quantity += 2
+        line_item.target_shipment = order.shipments.first
+
+        line_item.save
+        expect(line_item.errors_on(:quantity).size).to eq(1)
+      end
+    end
+
+    context "2 items left on stock" do
+      before do
+        variant.stock_items.update_all count_on_hand: 7, backorderable: false
+        order.contents.add(variant, 5)
+        order.create_proposed_shipments
+        order.finalize!
+      end
+
+      it "allows to increase quantity up to stock availability" do
+        line_item = order.line_items.first
+        line_item.quantity += 2
+        line_item.target_shipment = order.shipments.first
+
+        line_item.save
+        expect(line_item.errors_on(:quantity).size).to eq(0)
+      end
+
+      it "doesnt allow to increase quantity over stock availability" do
+        line_item = order.line_items.first
+        line_item.quantity += 3
+        line_item.target_shipment = order.shipments.first
+
+        line_item.save
+        expect(line_item.errors_on(:quantity).size).to eq(1)
+      end
+    end
+  end
+
+  context "currency same as order.currency" do
+    it "is a valid line item" do
+      line_item = order.line_items.first
+      line_item.currency = order.currency
+      line_item.valid?
+
+      expect(line_item.error_on(:currency).size).to eq(0)
+    end
+  end
+
+  context "currency different than order.currency" do
+    it "is not a valid line item" do
+      line_item = order.line_items.first
+      line_item.currency = "no currency"
+      line_item.valid?
+
+      expect(line_item.error_on(:currency).size).to eq(1)
+    end
+  end
+
+  describe "#options=" do
+    it "can handle updating a blank line item with no order" do
+      line_item.options = { price: 123 }
+    end
+
+    it "updates the data provided in the options" do
+      line_item.options = { price: 123 }
+      expect(line_item.price).to eq 123
+    end
+
+    it "updates the price based on the options provided" do
+      expect(line_item).to receive(:gift_wrap=).with(true)
+      expect(line_item.variant).to receive(:gift_wrap_price_modifier_amount_in).with("USD", true).and_return 1.99
+      line_item.options = { gift_wrap: true }
+      expect(line_item.price).to eq 21.98
+    end
+  end
+
+  describe "precision of pre_tax_amount" do
+    let(:line_item) { create :line_item, pre_tax_amount: 4.2051 }
+
+    it "keeps four digits of precision even when reloading" do
+      # prevent it from updating pre_tax_amount
+      allow_any_instance_of(Spree::LineItem).to receive(:update_tax_charge)
+      expect(line_item.reload.pre_tax_amount).to eq(4.2051)
+    end
+  end
+end