solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/order/finalizing_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Order, type: :model do
-  context "#finalize!" do
-    let(:order) { create(:order_ready_to_complete) }
-
-    before do
-      order.update_column :state, 'complete'
-    end
-
-    it "should set completed_at" do
-      expect(order).to receive(:touch).with(:completed_at)
-      order.finalize!
-    end
-
-    it "should sell inventory units" do
-      order.shipments.each do |shipment|
-        expect(shipment).to receive(:update_state)
-        expect(shipment).to receive(:finalize!)
-      end
-      order.finalize!
-    end
-
-    it "should change the shipment state to ready if order is paid" do
-      allow(order).to receive_messages(paid?: true, complete?: true)
-      order.finalize!
-      order.reload # reload so we're sure the changes are persisted
-      expect(order.shipment_state).to eq('ready')
-    end
-
-    it "should send an order confirmation email" do
-      mail_message = double "Mail::Message"
-      expect(Spree::OrderMailer).to receive(:confirm_email).with(order).and_return mail_message
-      expect(mail_message).to receive :deliver_later
-      order.finalize!
-    end
-
-    it "sets confirmation delivered when finalizing" do
-      expect(order.confirmation_delivered?).to be false
-      order.finalize!
-      expect(order.confirmation_delivered?).to be true
-    end
-
-    it "should not send duplicate confirmation emails" do
-      order.update(confirmation_delivered: true)
-      expect(Spree::OrderMailer).not_to receive(:confirm_email)
-      order.finalize!
-    end
-
-    it "should freeze all adjustments" do
-      # Stub this method as it's called due to a callback
-      # and it's irrelevant to this test
-      allow(Spree::OrderMailer).to receive_message_chain :confirm_email, :deliver_later
-      adjustments = [double]
-      expect(order).to receive(:all_adjustments).and_return(adjustments)
-      adjustments.each do |adj|
-        expect(adj).to receive(:finalize!)
-      end
-      order.finalize!
-    end
-
-    context "order is considered risky" do
-      before do
-        allow(order).to receive_messages is_risky?: true
-      end
-
-      context "and order is approved" do
-        before do
-          allow(order).to receive_messages approved?: true
-        end
-
-        it "should leave order in complete state" do
-          order.finalize!
-          expect(order.state).to eq 'complete'
-        end
-      end
-    end
-
-    context "order is not considered risky" do
-      before do
-        allow(order).to receive_messages is_risky?: false
-      end
-
-      it "should set completed_at" do
-        order.finalize!
-        expect(order.completed_at).to be_present
-      end
-    end
-  end
-end

data/spec/models/spree/order/number_generator_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Order::NumberGenerator do
-  subject { described_class.new.generate }
-
-  it { is_expected.to be_a(String) }
-
-  describe 'length' do
-    let(:default_length) do
-      Spree::Order::ORDER_NUMBER_LENGTH + Spree::Order::ORDER_NUMBER_PREFIX.length
-    end
-
-    it { expect(subject.length).to eq default_length }
-
-    context "when length option is 5" do
-      let(:option_length) { 5 + Spree::Order::ORDER_NUMBER_PREFIX.length }
-
-      subject { described_class.new(length: 5).generate }
-
-      it "should be 5 plus default prefix length" do
-        expect(subject.length).to eq option_length
-      end
-    end
-  end
-
-  context "when letters option is true" do
-    subject { described_class.new(letters: true).generate }
-
-    it "generates order number including letters" do
-      is_expected.to match /[A-Z]/
-    end
-  end
-
-  describe 'prefix' do
-    it { is_expected.to match /^#{Spree::Order::ORDER_NUMBER_PREFIX}/ }
-
-    context "when prefix option is 'P'" do
-      subject { described_class.new(prefix: 'P').generate }
-
-      it "generates order number prefixed with 'P'" do
-        is_expected.to match /^P/
-      end
-    end
-  end
-end

data/spec/models/spree/order/outstanding_balance_integration_spec.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-# This method in particular has been difficult to get right.
-# Many things will affect this amount
-#
-# See also:
-# https://github.com/solidusio/solidus/issues/1254
-# https://github.com/spree/spree/issues/6229
-# https://github.com/solidusio/solidus/issues/1107
-# https://github.com/solidusio/solidus/pull/1557
-# https://github.com/solidusio/solidus/pull/1536
-
-RSpec.describe "Outstanding balance integration tests" do
-  let!(:order) { create(:order_with_line_items, line_items_count: 2, line_items_price: 3, shipment_cost: 13) }
-  let(:item_1) { order.line_items[0] }
-  let(:item_2) { order.line_items[1] }
-  before { order.update!(state: 'complete', completed_at: Time.now) }
-
-  subject do
-    order.reload
-    order.recalculate
-    order.outstanding_balance
-  end
-
-  context 'when the order is unpaid' do
-    it { should eq order.total }
-    it { should eq 19 }
-
-    context 'when the order is cancelled' do
-      before { order.cancel! }
-      it { should eq 0 }
-    end
-  end
-
-  context 'when the order is fully paid' do
-    let!(:payment) { create(:payment, :completed, order: order, amount: order.total) }
-    it { should eq 0 }
-
-    context 'and there is a full refund' do
-      let!(:refund) { create(:refund, payment: payment, amount: payment.amount) }
-      it { should eq 19 }
-    end
-
-    context 'when the order is cancelled' do
-      before { order.update!(state: "canceled") }
-      it { should eq(-19) }
-
-      context 'and the payment is voided' do
-        before { payment.update!(state: "void") }
-        it { should eq 0 }
-      end
-
-      context 'and there is a full refund' do
-        let!(:refund) { create(:refund, payment: payment, amount: payment.amount) }
-        it { should eq 0 }
-      end
-
-      context 'and there is a partial refund' do
-        let!(:refund) { create(:refund, payment: payment, amount: 6) }
-        it { should eq(-13) }
-      end
-    end
-
-    context 'with a removed item' do
-      before do
-        item_amount = item_1.total
-        order.contents.remove(item_1.variant)
-        create(:refund, payment: payment, amount: item_amount)
-      end
-
-      it { should eq(0) }
-    end
-
-    context 'when the order is adjusted downward by an admin' do
-      let!(:adjustment) { create(:adjustment, order: order, adjustable: item_1, amount: -1, source: nil) }
-      let!(:refund) { create(:refund, payment: payment, amount: 1) }
-
-      it { should eq(0) }
-    end
-
-    context 'with a cancelled item' do
-      let(:cancelations) { Spree::OrderCancellations.new(order) }
-      let(:cancelled_item) { item_1 }
-      let(:created_by_user) { create(:user, email: 'user@email.com') }
-
-      before do
-        # Required to refund
-        Spree::RefundReason.create!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false)
-
-        cancelations.cancel_unit(cancelled_item.inventory_units.first)
-        cancelations.reimburse_units(cancelled_item.inventory_units, created_by: created_by_user)
-
-        order.reload
-      end
-
-      it 'discounts the cancelled item amount' do
-        expect(order.refund_total).to eq(3)
-        expect(order.reimbursement_total).to eq(3)
-        expect(order.payment_total).to eq(16)
-        expect(order.outstanding_balance).to eq(0)
-
-        expect(order.total).to eq(19)
-      end
-    end
-  end
-
-  context 'when the order is partly paid' do
-    let!(:payment) { create(:payment, :completed, order: order, amount: 10) }
-    it { should eq 9 }
-
-    context 'and there is a full refund' do
-      let!(:refund) { create(:refund, payment: payment, amount: payment.amount) }
-      it { should eq 19 }
-    end
-
-    context 'when the order is cancelled' do
-      before { order.update!(state: "canceled") }
-      it { should eq(-10) }
-
-      context 'and the payment is voided' do
-        before { payment.update!(state: "void") }
-        it { should eq 0 }
-      end
-
-      context 'and there is a full refund' do
-        let!(:refund) { create(:refund, payment: payment, amount: payment.amount) }
-        it { should eq 0 }
-      end
-
-      context 'and there is a partial refund' do
-        let!(:refund) { create(:refund, payment: payment, amount: 6) }
-        it { should eq(-4) }
-      end
-    end
-  end
-end

data/spec/models/spree/order/payment_spec.rb

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Spree::Order, type: :model do
-    let(:order) { stub_model(Spree::Order) }
-    let(:updater) { Spree::OrderUpdater.new(order) }
-
-    context "processing payments" do
-      let(:order) { create(:order_with_line_items, shipment_cost: 0, line_items_price: 100) }
-
-      before do
-        # So that Payment#purchase! is called during processing
-        stub_spree_preferences(auto_capture: true)
-      end
-
-      let(:payment_method) { create(:credit_card_payment_method) }
-
-      let!(:payment_1) do
-        create(:payment, payment_method: payment_method, order: order, amount: 50)
-      end
-
-      context 'sharing the same payment method' do
-        let!(:payment_2) do
-          create(:payment, payment_method: payment_method, order: order, amount: 50)
-        end
-
-        it 'processes only new payments' do
-          order.process_payments!
-          updater.update_payment_state
-
-          expect(order.payment_state).to eq('balance_due')
-          expect(order.payment_total).to eq(50)
-
-          expect(payment_1).to be_invalid
-          expect(payment_2).to be_completed
-        end
-      end
-
-      context 'with different payment methods that are store credit' do
-        let!(:payment_2) { create(:store_credit_payment, order: order, amount: 50) }
-
-        it 'processes all checkout payments' do
-          order.process_payments!
-          updater.update_payment_state
-
-          expect(order.payment_state).to eq('paid')
-          expect(order.payment_total).to eq(100)
-
-          expect(payment_1).to be_completed
-          expect(payment_2).to be_completed
-        end
-
-        context 'with over paid payments' do
-          let!(:payment_3) { create(:store_credit_payment, order: order, amount: 50) }
-
-          it 'does not go over total for order' do
-            order.process_payments!
-            updater.update_payment_state
-
-            expect(order.payment_state).to eq('paid')
-            expect(order.payment_total).to eq(100)
-            expect(payment_1).to be_completed
-            expect(payment_2).to be_completed
-            expect(payment_3).to be_checkout
-          end
-        end
-      end
-
-      context 'with failed payments' do
-        let!(:payment_2) do
-          create(:payment,
-            payment_method: payment_method,
-            order: order,
-            amount: 50,
-            state: 'failed')
-        end
-
-        it "does not use failed payments" do
-          expect(payment_1).to receive(:process!).and_call_original
-          expect(payment_2).not_to receive(:process!)
-
-          order.process_payments!
-
-          expect(order.payment_total).to eq(50)
-        end
-      end
-    end
-
-    context "with payments completed" do
-      it "should not fail transitioning to complete when paid" do
-        expect(order).to receive_messages total: 100, payment_total: 100
-        expect(order.process_payments!).to be_truthy
-      end
-    end
-
-    context "ensure source attributes stick around" do
-      let(:order){ Spree::Order.create }
-      let(:payment_method){ create(:credit_card_payment_method) }
-      let(:payment_attributes) do
-        {
-          payment_method_id: payment_method.id,
-          source_attributes: {
-            name: "Ryan Bigg",
-            number: "41111111111111111111",
-            expiry: "01 / 15",
-            verification_value: "123"
-          }
-        }
-      end
-
-      it "keeps source attributes on assignment" do
-        OrderUpdateAttributes.new(order, payments_attributes: [payment_attributes]).apply
-        expect(order.unprocessed_payments.last.source.number).to be_present
-      end
-
-      # For the reason of this test, please see spree/spree_gateway#132
-      it "keeps source attributes through OrderUpdateAttributes" do
-        OrderUpdateAttributes.new(order, payments_attributes: [payment_attributes]).apply
-        expect(order.unprocessed_payments.last.source.number).to be_present
-      end
-    end
-
-    context "checking if order is paid" do
-      context "payment_state is paid" do
-        before { allow(order).to receive_messages payment_state: 'paid' }
-        it { expect(order).to be_paid }
-      end
-
-      context "payment_state is credit_owned" do
-        before { allow(order).to receive_messages payment_state: 'credit_owed' }
-        it { expect(order).to be_paid }
-      end
-    end
-
-    context "#process_payments!" do
-      let(:payment) { stub_model(Spree::Payment) }
-      before { allow(order).to receive_messages unprocessed_payments: [payment], total: 10 }
-
-      it "should process the payments" do
-        expect(payment).to receive(:process!)
-        expect(order.process_payments!).to be_truthy
-      end
-
-      context "when a payment raises a GatewayError" do
-        before { expect(payment).to receive(:process!).and_raise(Spree::Core::GatewayError) }
-
-        it "should return true when configured to allow checkout on gateway failures" do
-          stub_spree_preferences(allow_checkout_on_gateway_error: true)
-          expect(order.process_payments!).to be true
-        end
-
-        it "should return false when not configured to allow checkout on gateway failures" do
-          stub_spree_preferences(allow_checkout_on_gateway_error: false)
-          expect(order.process_payments!).to be false
-        end
-      end
-    end
-
-    context "#authorize_payments!" do
-      let(:payment) { stub_model(Spree::Payment) }
-      before { allow(order).to receive_messages unprocessed_payments: [payment], total: 10 }
-      subject { order.authorize_payments! }
-
-      it "processes payments with attempt_authorization!" do
-        expect(payment).to receive(:authorize!)
-        subject
-      end
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "#capture_payments!" do
-      let(:payment) { stub_model(Spree::Payment) }
-      before { allow(order).to receive_messages unprocessed_payments: [payment], total: 10 }
-      subject { order.capture_payments! }
-
-      it "processes payments with attempt_authorization!" do
-        expect(payment).to receive(:purchase!)
-        subject
-      end
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "#outstanding_balance" do
-      it "should return positive amount when payment_total is less than total" do
-        order.payment_total = 20.20
-        order.total = 30.30
-        expect(order.outstanding_balance).to eq(10.10)
-      end
-      it "should return negative amount when payment_total is greater than total" do
-        order.total = 8.20
-        order.payment_total = 10.20
-        expect(order.outstanding_balance).to be_within(0.001).of(-2.00)
-      end
-
-      context "with reimburesements on the order" do
-        let(:amount) { 10.0 }
-        let(:reimbursement) { create(:reimbursement) }
-        let(:order) { reimbursement.order.reload }
-
-        before do
-          # Set the payment amount to actually be the order total of 110
-          reimbursement.order.payments.first.update_column :amount, amount
-          # Creates a refund of 110
-          create :refund, amount: amount,
-                          payment: reimbursement.order.payments.first,
-                          reimbursement: reimbursement
-          # Update the order totals so payment_total goes to 0 reflecting the refund..
-          order.recalculate
-        end
-
-        context "for canceled orders" do
-          before { order.update(state: 'canceled') }
-
-          it "it should be zero" do
-            expect(order.total).to eq(110)
-            expect(order.payments.sum(:amount)).to eq(10)
-            expect(order.refund_total).to eq(10)
-            expect(order.reimbursement_total).to eq(10)
-            expect(order.payment_total).to eq(0)
-            expect(order.outstanding_balance).to eq(0)
-          end
-        end
-
-        context "for non-canceled orders" do
-          it 'should incorporate refund reimbursements' do
-            # Order Total - (Payment Total + Reimbursed)
-            # 110 - (0 + 10) = 100
-            expect(order.outstanding_balance).to eq 100
-          end
-        end
-      end
-    end
-
-    context "#outstanding_balance?" do
-      it "should be true when total greater than payment_total" do
-        order.total = 10.10
-        order.payment_total = 9.50
-        expect(order.outstanding_balance?).to be true
-      end
-      it "should be true when total less than payment_total" do
-        order.total = 8.25
-        order.payment_total = 10.44
-        expect(order.outstanding_balance?).to be true
-      end
-      it "should be false when total equals payment_total" do
-        order.total = 10.10
-        order.payment_total = 10.10
-        expect(order.outstanding_balance?).to be false
-      end
-    end
-
-    context "payment_required?" do
-      before { order.total = total }
-
-      context "total is zero" do
-        let(:total) { 0 }
-        it { expect(order).not_to be_payment_required }
-      end
-
-      context "total is once cent" do
-        let(:total) { 1 }
-        it { expect(order).to be_payment_required }
-      end
-
-      context "total is once dollar" do
-        let(:total) { 1 }
-        it { expect(order).to be_payment_required }
-      end
-
-      context "total is huge" do
-        let(:total) { 2**32 }
-        it { expect(order).to be_payment_required }
-      end
-    end
-  end
-end

data/spec/models/spree/order/risk_assessment_spec.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Order, type: :model do
-  let(:order) { stub_model('Spree::Order') }
-
-  describe ".is_risky?" do
-    context "Not risky order" do
-      let(:order) { FactoryBot.create(:order, payments: [payment]) }
-      context "with avs_response == D" do
-        let(:payment) { FactoryBot.create(:payment, avs_response: "D") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with avs_response == M" do
-        let(:payment) { FactoryBot.create(:payment, avs_response: "M") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with avs_response == ''" do
-        let(:payment) { FactoryBot.create(:payment, avs_response: "") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with cvv_response_code == M" do
-        let(:payment) { FactoryBot.create(:payment, cvv_response_code: "M") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with cvv_response_message == ''" do
-        let(:payment) { FactoryBot.create(:payment, cvv_response_message: "") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-    end
-
-    context "Risky order" do
-      context "AVS response message" do
-        let(:order) { FactoryBot.create(:order, payments: [FactoryBot.create(:payment, avs_response: "A")]) }
-        it "returns true if the order has an avs_response" do
-          expect(order.is_risky?).to eq(true)
-        end
-      end
-
-      context "CVV response code" do
-        let(:order) { FactoryBot.create(:order, payments: [FactoryBot.create(:payment, cvv_response_code: "N")]) }
-        it "returns true if the order has an cvv_response_code" do
-          expect(order.is_risky?).to eq(true)
-        end
-      end
-
-      context "state == 'failed'" do
-        let(:order) { FactoryBot.create(:order, payments: [FactoryBot.create(:payment, state: 'failed')]) }
-        it "returns true if the order has state == 'failed'" do
-          expect(order.is_risky?).to eq(true)
-        end
-      end
-    end
-  end
-end