solidus_core 2.10.0 → 2.11.0

data/spec/models/spree/credit_card_spec.rb

@@ -1,373 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::CreditCard, type: :model do
-  let(:valid_credit_card_attributes) do
-    {
-      number: '4111111111111111',
-      verification_value: '123',
-      expiry: "12 / #{(Time.current.year + 1).to_s.last(2)}",
-      name: 'Spree Commerce'
-    }
-  end
-
-  def self.payment_states
-    Spree::Payment.state_machine.states.keys
-  end
-
-  let(:credit_card) { Spree::CreditCard.new }
-
-  it_behaves_like 'a payment source'
-
-  before(:each) do
-    @order = create(:order)
-    @payment = Spree::Payment.create(amount: 100, order: @order)
-
-    @success_response = double('gateway_response', success?: true, authorization: '123', avs_result: { 'code' => 'avs-code' })
-    @fail_response = double('gateway_response', success?: false)
-
-    @payment_gateway = mock_model(Spree::PaymentMethod,
-      payment_profiles_supported?: true,
-      authorize: @success_response,
-      purchase: @success_response,
-      capture: @success_response,
-      void: @success_response,
-      credit: @success_response)
-
-    allow(@payment).to receive_messages payment_method: @payment_gateway
-  end
-
-  describe "#valid?" do
-    it "should validate presence of number" do
-      credit_card.attributes = valid_credit_card_attributes.except(:number)
-      expect(credit_card).not_to be_valid
-      expect(credit_card.errors[:number]).to eq(["can't be blank"])
-    end
-
-    it "should validate presence of security code" do
-      credit_card.attributes = valid_credit_card_attributes.except(:verification_value)
-      expect(credit_card).not_to be_valid
-      expect(credit_card.errors[:verification_value]).to eq(["can't be blank"])
-    end
-
-    it "validates name presence" do
-      credit_card.valid?
-      expect(credit_card.errors[:name].size).to eq(1)
-    end
-
-    it "should only validate on create" do
-      credit_card.attributes = valid_credit_card_attributes
-      credit_card.save
-      expect(credit_card).to be_valid
-    end
-
-    context "encrypted data is present" do
-      it "does not validate presence of number or cvv" do
-        credit_card.encrypted_data = "$fdgsfgdgfgfdg&gfdgfdgsf-"
-        credit_card.valid?
-        expect(credit_card.errors[:number]).to be_empty
-        expect(credit_card.errors[:verification_value]).to be_empty
-      end
-    end
-
-    context "imported is true" do
-      it "does not validate presence of number or cvv" do
-        credit_card.imported = true
-        credit_card.valid?
-        expect(credit_card.errors[:number]).to be_empty
-        expect(credit_card.errors[:verification_value]).to be_empty
-      end
-    end
-  end
-
-  describe "#save" do
-    before do
-      credit_card.attributes = valid_credit_card_attributes
-      credit_card.save!
-    end
-
-    let!(:persisted_card) { Spree::CreditCard.find(credit_card.id) }
-    let(:valid_address_attributes) do
-      {
-        firstname: "Hugo",
-        lastname: "Furst",
-        address1: "123 Main",
-        city: "Somewhere",
-        country_id: 1,
-        zipcode: 55_555,
-        phone: "1234567890"
-      }
-    end
-
-    it "should not actually store the number" do
-      expect(persisted_card.number).to be_blank
-    end
-
-    it "should not actually store the security code" do
-      expect(persisted_card.verification_value).to be_blank
-    end
-
-    it "should save and update addresses through nested attributes" do
-      persisted_card.update({ address_attributes: valid_address_attributes })
-      persisted_card.save!
-      updated_attributes = { id: persisted_card.address.id, address1: "123 Main St." }
-      persisted_card.update({ address_attributes: updated_attributes })
-      expect(persisted_card.address.address1).to eq "123 Main St."
-    end
-  end
-
-  describe "#number=" do
-    it "should strip non-numeric characters from card input" do
-      credit_card.number = "6011000990139424"
-      expect(credit_card.number).to eq("6011000990139424")
-
-      credit_card.number = "  6011-0009-9013-9424  "
-      expect(credit_card.number).to eq("6011000990139424")
-    end
-
-    it "should not raise an exception on non-string input" do
-      credit_card.number = {}
-      expect(credit_card.number).to be_nil
-    end
-  end
-
-  describe "#verification_value=" do
-    it "accepts a valid 3-digit value" do
-      credit_card.verification_value = "123"
-      expect(credit_card.verification_value).to eq("123")
-    end
-
-    it "accepts a valid 4-digit value" do
-      credit_card.verification_value = "1234"
-      expect(credit_card.verification_value).to eq("1234")
-    end
-
-    it "stringifies an integer" do
-      credit_card.verification_value = 123
-      expect(credit_card.verification_value).to eq("123")
-    end
-
-    it "strips any whitespace" do
-      credit_card.verification_value = ' 1 2  3 '
-      expect(credit_card.verification_value).to eq('123')
-    end
-  end
-
-  # Regression test for https://github.com/spree/spree/issues/3847 and https://github.com/spree/spree/issues/3896
-  describe "#expiry=" do
-    it "can set with a 2-digit month and year" do
-      credit_card.expiry = '04 / 15'
-      expect(credit_card.month).to eq('4')
-      expect(credit_card.year).to eq('2015')
-    end
-
-    it "can set with a 2-digit month and 4-digit year" do
-      credit_card.expiry = '04 / 2015'
-      expect(credit_card.month).to eq('4')
-      expect(credit_card.year).to eq('2015')
-    end
-
-    it "can set with a 2-digit month and 4-digit year without whitespace" do
-      credit_card.expiry = '04/15'
-      expect(credit_card.month).to eq('4')
-      expect(credit_card.year).to eq('2015')
-    end
-
-    it "can set with a 2-digit month and 4-digit year without whitespace" do
-      credit_card.expiry = '04/2015'
-      expect(credit_card.month).to eq('4')
-      expect(credit_card.year).to eq('2015')
-    end
-
-    it "can set with a 2-digit month and 4-digit year without whitespace and slash" do
-      credit_card.expiry = '042015'
-      expect(credit_card.month).to eq('4')
-      expect(credit_card.year).to eq('2015')
-    end
-
-    it "can set with a 2-digit month and 2-digit year without whitespace and slash" do
-      credit_card.expiry = '0415'
-      expect(credit_card.month).to eq('4')
-      expect(credit_card.year).to eq('2015')
-    end
-
-    it "does not blow up when passed an empty string" do
-      credit_card.expiry = ''
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/4725
-    it "does not blow up when passed one number" do
-      credit_card.expiry = '12'
-    end
-  end
-
-  describe "#cc_type=" do
-    it "converts between the different types" do
-      credit_card.cc_type = 'mastercard'
-      expect(credit_card.cc_type).to eq('master')
-
-      credit_card.cc_type = 'maestro'
-      expect(credit_card.cc_type).to eq('master')
-
-      credit_card.cc_type = 'amex'
-      expect(credit_card.cc_type).to eq('american_express')
-
-      credit_card.cc_type = 'dinersclub'
-      expect(credit_card.cc_type).to eq('diners_club')
-
-      credit_card.cc_type = 'some_outlandish_cc_type'
-      expect(credit_card.cc_type).to eq('some_outlandish_cc_type')
-    end
-
-    it "assigns the type based on card number in the event of js failure" do
-      credit_card.number = '4242424242424242'
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('visa')
-
-      credit_card.number = '5555555555554444'
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('master')
-
-      credit_card.number = '2221000000000000'
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('master')
-
-      credit_card.number = '378282246310005'
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('american_express')
-
-      credit_card.number = '30569309025904'
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('diners_club')
-
-      credit_card.number = '3530111333300000'
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('jcb')
-
-      credit_card.number = ''
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('')
-
-      credit_card.number = nil
-      credit_card.cc_type = ''
-      expect(credit_card.cc_type).to eq('')
-    end
-  end
-
-  describe "#to_active_merchant" do
-    before do
-      credit_card.number = "4111111111111111"
-      credit_card.year = Time.current.year
-      credit_card.month = Time.current.month
-      credit_card.name = "Ludwig van Beethoven"
-      credit_card.verification_value = 123
-    end
-
-    it "converts to an ActiveMerchant::Billing::CreditCard object" do
-      am_card = credit_card.to_active_merchant
-      expect(am_card.number).to eq("4111111111111111")
-      expect(am_card.year).to eq(Time.current.year)
-      expect(am_card.month).to eq(Time.current.month)
-      expect(am_card.first_name).to eq("Ludwig")
-      expect(am_card.last_name).to eq("van Beethoven")
-      expect(am_card.verification_value).to eq("123")
-    end
-  end
-
-  # TODO: Remove these specs once default is removed
-  describe 'default' do
-    def default_with_silence(card)
-      Spree::Deprecation.silence { card.default }
-    end
-
-    context 'with a user' do
-      let(:user) { create(:user) }
-      let(:credit_card) { create(:credit_card, user: user) }
-
-      it 'uses the wallet information' do
-        wallet_payment_source = user.wallet.add(credit_card)
-        user.wallet.default_wallet_payment_source = wallet_payment_source
-
-        expect(default_with_silence(credit_card)).to be_truthy
-      end
-    end
-
-    context 'without a user' do
-      let(:credit_card) { create(:credit_card) }
-
-      it 'returns false' do
-        expect(default_with_silence(credit_card)).to eq(false)
-      end
-    end
-  end
-
-  # TODO: Remove these specs once default= is removed
-  describe 'default=' do
-    def default_with_silence(card)
-      Spree::Deprecation.silence { card.default }
-    end
-
-    context 'with a user' do
-      let(:user) { create(:user) }
-      let(:credit_card) { create(:credit_card, user: user) }
-
-      it 'updates the wallet information' do
-        Spree::Deprecation.silence do
-          credit_card.default = true
-        end
-        expect(user.wallet.default_wallet_payment_source.payment_source).to eq(credit_card)
-      end
-    end
-
-    context 'with multiple cards for one user' do
-      let(:user) { create(:user) }
-      let(:first_card) { create(:credit_card, user: user) }
-      let(:second_card) { create(:credit_card, user: user) }
-
-      it 'ensures only one default' do
-        Spree::Deprecation.silence do
-          first_card.default = true
-          second_card.default = true
-        end
-
-        expect(default_with_silence(first_card)).to be_falsey
-        expect(default_with_silence(second_card)).to be_truthy
-
-        Spree::Deprecation.silence do
-          first_card.default = true
-        end
-
-        expect(default_with_silence(first_card)).to be_truthy
-        expect(default_with_silence(second_card)).to be_falsey
-      end
-    end
-
-    context 'with multiple cards for different users' do
-      let(:first_card) { create(:credit_card, user: create(:user)) }
-      let(:second_card) { create(:credit_card, user: create(:user)) }
-
-      it 'allows multiple defaults' do
-        Spree::Deprecation.silence do
-          first_card.default = true
-          second_card.default = true
-        end
-
-        expect(default_with_silence(first_card)).to be_truthy
-        expect(default_with_silence(second_card)).to be_truthy
-      end
-    end
-
-    context 'without a user' do
-      let(:credit_card) { create(:credit_card) }
-
-      it 'raises' do
-        expect {
-          Spree::Deprecation.silence do
-            credit_card.default = true
-          end
-        }.to raise_error("Cannot set 'default' on a credit card without a user")
-      end
-    end
-  end
-end

data/spec/models/spree/customer_return_spec.rb

@@ -1,294 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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_order) { create(:order_with_line_items) }
-      let(:second_order) { first_order }
-
-      let(:first_shipment) { first_order.shipments.first }
-      let(:second_shipment) { second_order.shipments.first }
-
-      let(:first_inventory_unit)  { build(:inventory_unit, shipment: first_shipment) }
-      let(:first_return_item)     { build(:return_item, inventory_unit: first_inventory_unit) }
-
-      let(:second_inventory_unit) { build(:inventory_unit, shipment: second_shipment) }
-      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_with_line_items) }
-
-        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(I18n.t('spree.return_items_cannot_be_associated_with_multiple_orders'))
-        end
-      end
-
-      context "return items are part of the same order" do
-        let(:second_order) { first_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(: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(amount: 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((amount * 2) + (tax_amount * 2))
-    end
-  end
-
-  describe "#display_total" do
-    let(:customer_return) { stub_model(Spree::CustomerReturn, total: 21.22, currency: "GBP") }
-
-    it "returns a Spree::Money" do
-      expect(customer_return.display_total).to eq(Spree::Money.new(21.22, currency: "GBP"))
-    end
-  end
-
-  describe "#currency" do
-    let(:order) { stub_model(Spree::Order, currency: "GBP") }
-    let(:customer_return) { stub_model(Spree::CustomerReturn, order: order) }
-
-    it 'returns the order currency' do
-      expect(Spree::Config.currency).to eq("USD")
-      expect(customer_return.currency).to eq("GBP")
-    end
-  end
-
-  describe "#amount" do
-    let(: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(amount: amount)
-    end
-
-    subject { customer_return.amount }
-
-    it "returns the sum of the return item's amount" do
-      expect(subject).to eq(amount * 2)
-    end
-  end
-
-  describe "#display_amount" do
-    let(:customer_return) { stub_model(Spree::CustomerReturn, amount: 21.22, currency: "RUB") }
-
-    it "returns a Spree::Money" do
-      expect(customer_return.display_amount).to eq(Spree::Money.new(21.22, currency: "RUB"))
-    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
-          stub_spree_preferences(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.really_destroy!
-        create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: new_stock_location.id)
-      end
-
-      it "should NOT raise an error when a soft-deleted stock item exists in the stock location" do
-        inventory_unit.find_stock_item.discard
-        create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: new_stock_location.id)
-      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!(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
-            let(:created_by_user) { create(:user, email: 'user@email.com') }
-            before { reimbursement.perform!(created_by: created_by_user) }
-
-            it { is_expected.to be true }
-          end
-        end
-      end
-    end
-  end
-end