solidus_core 1.0.2 → 1.0.3

data/spec/models/spree/customer_return_spec.rb

@@ -0,0 +1,276 @@
+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 "#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 ".before_create" do
+    describe "#generate_number" do
+      context "number is assigned" do
+        let(:customer_return) { Spree::CustomerReturn.new(number: '123') }
+
+        it "should return the assigned number" do
+          customer_return.save
+          expect(customer_return.number).to eq('123')
+        end
+      end
+
+      context "number is not assigned" do
+        let(:customer_return) { Spree::CustomerReturn.new(number: nil) }
+
+        before do
+          allow(customer_return).to receive_messages(valid?: true, process_return!: true)
+        end
+
+        it "should assign number with random CR number" do
+          customer_return.save
+          expect(customer_return.number).to match(/CR\d{9}/)
+        end
+      end
+    end
+  end
+
+  describe "#total" do
+    let(:pre_tax_amount)  { 15.0 }
+    let(:tax_amount)  { 5.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, additional_tax_total: tax_amount)
+      customer_return.reload
+    end
+
+    subject { customer_return.total }
+
+    it "returns the sum of the return item's total amount" do
+      expect(subject).to eq ((pre_tax_amount * 2) + (tax_amount * 2))
+    end
+  end
+
+  describe "#display_total" do
+    let(:customer_return) { Spree::CustomerReturn.new }
+
+    it "returns a Spree::Money" do
+      allow(customer_return).to receive_messages(total: 21.22)
+      expect(customer_return.display_total).to eq(Spree::Money.new(21.22))
+    end
+  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)     { build(:return_item, inventory_unit: inventory_unit) }
+
+    context "to the initial stock location" do
+
+      it "should mark the received inventory units are returned" do
+        create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: inventory_unit.shipment.stock_location_id)
+        return_item.receive!
+        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)
+          return_item.receive!
+        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)
+          return_item.receive!
+        }.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
+
+    context "it was not received" do
+
+      before do
+        return_item.update_attributes!(reception_status: "lost_in_transit")
+      end
+
+      it 'should not updated inventory unit to 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 'shipped'
+      end
+
+      it "should not 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_not change { inventory_unit.find_stock_item.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,79 @@
+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, inventory_unit: inventory_unit) }
+      let(:return_items) { [return_item] }
+
+      let(:inventory_unit) { create(:inventory_unit, order: order, line_item: line_item) }
+      let(:order) { create(:shipped_order, line_items_count: 1) }
+      let(:line_item) { order.line_items.first }
+
+      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,82 @@
+require 'spec_helper'
+
+describe Spree::Gateway, :type => :model do
+  class Provider
+    def initialize(options)
+    end
+
+    def imaginary_method
+      'imaginary!'
+    end
+  end
+
+  class TestGateway < Spree::Gateway
+    def provider_class
+      Provider
+    end
+  end
+
+  it "passes through all arguments on a method_missing call" do
+    expect(TestGateway.new.imaginary_method).to eq 'imaginary!'
+  end
+
+  context "fetching payment sources" do
+    let(:user) { create :user }
+    let(:order) { Spree::Order.create(user: user, completed_at: completed_at) }
+
+    let(:payment_method) { create(:credit_card_payment_method) }
+
+    let(:cc) do
+      create(:credit_card,
+             payment_method: payment_method,
+             gateway_customer_profile_id: "EFWE",
+             user: cc_user)
+    end
+
+    let(:payment) do
+      create(:payment, order: order, source: cc, payment_method: payment_method)
+    end
+
+    context 'order is not complete and credit card user is nil' do
+      let(:cc_user) { nil }
+      let(:completed_at) { nil }
+
+      it "finds no credit cards associated to the order" do
+        expect(payment_method.reusable_sources(payment.order)).to be_empty
+      end
+    end
+
+    context 'order is complete but credit card user is nil' do
+      let(:cc_user) { nil }
+      let(:completed_at) { Date.yesterday }
+
+      it "finds credit cards associated on a order completed" do
+        expect(payment_method.reusable_sources(payment.order)).to eq [cc]
+      end
+    end
+
+    context 'order is not complete but credit card has user' do
+      let(:cc_user) { user }
+      let(:completed_at) { nil }
+
+      it "finds credit cards associated to the user" do
+        expect(payment_method.reusable_sources(payment.order)).to eq [cc]
+      end
+    end
+  end
+
+  context 'using preference_source' do
+    let(:klass){ Spree::Gateway::Bogus }
+    before do
+      Spree::Config.static_model_preferences.add(klass, 'test_preference_source', server: 'bar')
+    end
+    after do
+      Spree::Config.static_model_preferences.for_class(klass).clear
+    end
+    let(:payment_method){ create(:credit_card_payment_method, preference_source: 'test_preference_source') }
+
+    it "reads static preferences" do
+      expect(payment_method.options).to eq({:server=>"bar"})
+    end
+  end
+end