spree_core 3.2.1 → 3.2.2

data/spec/models/spree/customer_return_spec.rb

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

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

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

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

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

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

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