solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/customer_return_spec.rb

@@ -1,276 +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 "#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

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

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