spree_core 3.2.9 → 3.3.0.rc1

data/spec/models/spree/customer_return_spec.rb

@@ -0,0 +1,240 @@
+require 'spec_helper'
+
+describe Spree::CustomerReturn, type: :model do
+  before do
+    allow_any_instance_of(Spree::Order).to receive_messages(return!: true)
+  end
+
+  describe ".validation" do
+    describe "#must_have_return_authorization" do
+      let(:customer_return)       { build(:customer_return) }
+
+      let(:inventory_unit)  { build(:inventory_unit) }
+      let(:return_item)     { build(:return_item, inventory_unit: inventory_unit) }
+
+      subject { customer_return.valid? }
+
+      before do
+        customer_return.return_items << return_item
+      end
+
+      context "return item does not belong to return authorization" do
+        before do
+          return_item.return_authorization = nil
+        end
+
+        it "is not valid" do
+          expect(subject).to eq false
+        end
+
+        it "adds an error message" do
+          subject
+          expect(customer_return.errors.full_messages).to include(Spree.t(:missing_return_authorization, item_name: inventory_unit.variant.name))
+        end
+      end
+
+      context "return item belongs to return authorization" do
+        it "is valid" do
+          expect(subject).to eq true
+        end
+      end
+    end
+
+    describe "#return_items_belong_to_same_order" do
+      let(:customer_return)       { build(:customer_return) }
+
+      let(:first_inventory_unit)  { build(:inventory_unit) }
+      let(:first_return_item)     { build(:return_item, inventory_unit: first_inventory_unit) }
+
+      let(:second_inventory_unit) { build(:inventory_unit, order: second_order) }
+      let(:second_return_item)    { build(:return_item, inventory_unit: second_inventory_unit) }
+
+      subject { customer_return.valid? }
+
+      before do
+        customer_return.return_items << first_return_item
+        customer_return.return_items << second_return_item
+      end
+
+      context "return items are part of different orders" do
+        let(:second_order) { create(:order) }
+
+        it "is not valid" do
+          expect(subject).to eq false
+        end
+
+        it "adds an error message" do
+          subject
+          expect(customer_return.errors.full_messages).to include(Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
+        end
+      end
+
+      context "return items are part of the same order" do
+        let(:second_order) { first_inventory_unit.order }
+
+        it "is valid" do
+          expect(subject).to eq true
+        end
+      end
+    end
+  end
+
+  describe 'whitelisted_ransackable_attributes' do
+    it { expect(Spree::CustomerReturn.whitelisted_ransackable_attributes).to eq(%w(number)) }
+  end
+
+  describe "#pre_tax_total" do
+    let(:pre_tax_amount)  { 15.0 }
+    let(:customer_return) { create(:customer_return, line_items_count: 2) }
+
+    before do
+      Spree::ReturnItem.where(customer_return_id: customer_return.id).update_all(pre_tax_amount: pre_tax_amount)
+    end
+
+    subject { customer_return.pre_tax_total }
+
+    it "returns the sum of the return item's pre_tax_amount" do
+      expect(subject).to eq (pre_tax_amount * 2)
+    end
+  end
+
+  describe "#display_pre_tax_total" do
+    let(:customer_return) { Spree::CustomerReturn.new }
+
+    it "returns a Spree::Money" do
+      allow(customer_return).to receive_messages(pre_tax_total: 21.22)
+      expect(customer_return.display_pre_tax_total).to eq(Spree::Money.new(21.22))
+    end
+  end
+
+  describe "#order" do
+    let(:return_item) { create(:return_item) }
+    let(:customer_return) { build(:customer_return, return_items: [return_item]) }
+
+    subject { customer_return.order }
+
+    it "returns the order associated with the return item's inventory unit" do
+      expect(subject).to eq return_item.inventory_unit.order
+    end
+  end
+
+  describe "#order_id" do
+    subject { customer_return.order_id }
+
+    context "return item is not associated yet" do
+      let(:customer_return) { build(:customer_return) }
+
+      it "is nil" do
+        expect(subject).to be_nil
+      end
+    end
+
+    context "has an associated return item" do
+      let(:return_item) { create(:return_item) }
+      let(:customer_return) { build(:customer_return, return_items: [return_item]) }
+
+      it "is the return item's inventory unit's order id" do
+        expect(subject).to eq return_item.inventory_unit.order.id
+      end
+    end
+  end
+
+  context ".after_save" do
+    let(:inventory_unit)  { create(:inventory_unit, state: 'shipped', order: create(:shipped_order)) }
+    let(:return_item)     { create(:return_item, inventory_unit: inventory_unit) }
+
+    context "to the initial stock location" do
+
+      it "should mark all inventory units are returned" do
+        create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: inventory_unit.shipment.stock_location_id)
+        expect(inventory_unit.reload.state).to eq 'returned'
+      end
+
+      it "should update the stock item counts in the stock location" do
+        expect do
+          create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: inventory_unit.shipment.stock_location_id)
+        end.to change { inventory_unit.find_stock_item.count_on_hand }.by(1)
+      end
+
+      context 'with Config.track_inventory_levels == false' do
+        before do
+          Spree::Config.track_inventory_levels = false
+          expect(Spree::StockItem).not_to receive(:find_by)
+          expect(Spree::StockMovement).not_to receive(:create!)
+        end
+
+        it "should NOT update the stock item counts in the stock location" do
+          count_on_hand = inventory_unit.find_stock_item.count_on_hand
+          create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: inventory_unit.shipment.stock_location_id)
+          expect(inventory_unit.find_stock_item.count_on_hand).to eql count_on_hand
+        end
+      end
+    end
+
+    context "to a different stock location" do
+      let(:new_stock_location) { create(:stock_location, name: "other") }
+
+      it "should update the stock item counts in new stock location" do
+        expect {
+          create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: new_stock_location.id)
+        }.to change {
+          Spree::StockItem.where(variant_id: inventory_unit.variant_id, stock_location_id: new_stock_location.id).first.count_on_hand
+        }.by(1)
+      end
+
+      it "should NOT raise an error when no stock item exists in the stock location" do
+        inventory_unit.find_stock_item.destroy
+        expect { create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: new_stock_location.id) }.not_to raise_error
+      end
+
+      it "should not update the stock item counts in the original stock location" do
+        count_on_hand = inventory_unit.find_stock_item.count_on_hand
+        create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: new_stock_location.id)
+        expect(inventory_unit.find_stock_item.count_on_hand).to eq(count_on_hand)
+      end
+    end
+  end
+
+  describe '#fully_reimbursed?' do
+    let(:customer_return) { create(:customer_return) }
+
+    let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    subject { customer_return.fully_reimbursed? }
+
+    context 'when some return items are undecided' do
+      it { is_expected.to be false }
+    end
+
+    context 'when all return items are decided' do
+
+      context 'when all return items are rejected' do
+        before { customer_return.return_items.each(&:reject!) }
+
+        it { is_expected.to be true }
+      end
+
+      context 'when all return items are accepted' do
+        before { customer_return.return_items.each(&:accept!) }
+
+        context 'when some return items have no reimbursement' do
+          it { is_expected.to be false }
+        end
+
+        context 'when all return items have a reimbursement' do
+          let!(:reimbursement) { create(:reimbursement, customer_return: customer_return) }
+
+          context 'when some reimbursements are not reimbursed' do
+            it { is_expected.to be false }
+          end
+
+          context 'when all reimbursements are reimbursed' do
+            before { reimbursement.perform! }
+
+            it { is_expected.to be true }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/exchange_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Spree
+  describe Exchange, type: :model do
+    let(:order) { Spree::Order.new }
+
+    let(:return_item_1) { build(:exchange_return_item) }
+    let(:return_item_2) { build(:exchange_return_item) }
+    let(:return_items) { [return_item_1, return_item_2] }
+    let(:exchange) { Exchange.new(order, return_items) }
+
+    describe "#description" do
+      before do
+        allow(return_item_1).to receive(:variant) { double(options_text: "foo") }
+        allow(return_item_1).to receive(:exchange_variant) { double(options_text: "bar") }
+        allow(return_item_2).to receive(:variant) { double(options_text: "baz") }
+        allow(return_item_2).to receive(:exchange_variant) { double(options_text: "qux") }
+      end
+
+      it "describes the return items' change in options" do
+        expect(exchange.description).to match /foo => bar/
+        expect(exchange.description).to match /baz => qux/
+      end
+    end
+
+    describe "#display_amount" do
+      it "is the total amount of all return items" do
+        expect(exchange.display_amount).to eq Spree::Money.new(0.0)
+      end
+    end
+
+    describe "#perform!" do
+      let(:return_item) { create(:exchange_return_item) }
+      let(:return_items) { [return_item] }
+      let(:order) { return_item.return_authorization.order }
+      subject { exchange.perform! }
+      before { return_item.exchange_variant.stock_items.first.adjust_count_on_hand(20) }
+
+      it "creates shipments for the order with the return items exchange inventory units" do
+        expect { subject }.to change { order.shipments.count }.by(1)
+        new_shipment = order.shipments.last
+        expect(new_shipment).to be_ready
+        new_inventory_units = new_shipment.inventory_units
+        expect(new_inventory_units.count).to eq 1
+        expect(new_inventory_units.first.original_return_item).to eq return_item
+        expect(new_inventory_units.first.line_item).to eq return_item.inventory_unit.line_item
+      end
+
+      context "when it cannot create shipments for all items" do
+        before do
+          StockItem.where(:variant_id => return_item.exchange_variant_id).destroy_all
+        end
+
+        it 'raises an UnableToCreateShipments error' do
+          expect {
+            subject
+          }.to raise_error(Spree::Exchange::UnableToCreateShipments)
+        end
+      end
+    end
+
+    describe "#to_key" do # for dom_id
+      it { expect(Exchange.new(nil, nil).to_key).to be_nil }
+    end
+
+    describe ".param_key" do # for dom_id
+      it { expect(Exchange.param_key).to eq "spree_exchange" }
+    end
+
+    describe ".model_name" do # for dom_id
+      it { expect(Exchange.model_name).to eq Spree::Exchange }
+    end
+
+  end
+end

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(:saved_change_to_attachment_updated_at?) }
+  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