bring back order contents and store credit methods to ease upgrading …

…to spree 4

core/app/models/spree/order/store_credit.rb

@@ -1,6 +1,14 @@
 module Spree
   class Order < Spree::Base
     module StoreCredit
+      def add_store_credit_payments(amount = nil)
+        Spree::Dependencies.checkout_add_store_credit_service.constantize.call(order: self, amount: amount)
+      end
+
+      def remove_store_credit_payments
+        Spree::Dependencies.checkout_remove_store_credit_service.constantize.call(order: self)
+      end
+
       def covered_by_store_credit?
         return false unless user
 

core/app/models/spree/order_contents.rb

@@ -0,0 +1,31 @@
+module Spree
+  class OrderContents
+    attr_accessor :order, :currency
+
+    def initialize(order)
+      @order = order
+    end
+
+    def add(variant, quantity = 1, options = {})
+      Spree::Dependencies.cart_add_item_service.constantize.call(order: order,
+                                                                 variant: variant,
+                                                                 quantity: quantity,
+                                                                 options: options).value
+    end
+
+    def remove(variant, quantity = 1, options = {})
+      Spree::Dependencies.cart_remove_item_service.constantize.call(order: order,
+                                                                    variant: variant,
+                                                                    quantity: quantity,
+                                                                    options: options).value
+    end
+
+    def remove_line_item(line_item, options = {})
+      Spree::Cart::RemoveLineItem.call(order: @order, line_item: line_item, options: options).value
+    end
+
+    def update_cart(params)
+      Spree::Dependencies.cart_update_service.constantize.call(order: order, params: params).value
+    end
+  end
+end

core/spec/models/spree/order/store_credit_spec.rb

@@ -25,6 +25,129 @@
 end
 
 describe 'Order' do
+  describe '#add_store_credit_payments' do
+    subject { order.add_store_credit_payments }
+
+    let(:order_total) { 500.00 }
+
+    before { create(:store_credit_payment_method) }
+
+    context 'there is no store credit' do
+      let(:order) { create(:store_credits_order_without_user, total: order_total) }
+
+      before do
+        # callbacks recalculate total based on line items
+        # this ensures the total is what we expect
+        order.update_column(:total, order_total)
+        subject
+        order.reload
+      end
+
+      it 'does not create a store credit payment' do
+        expect(order.payments.count).to eq 0
+      end
+    end
+
+    context 'there is enough store credit to pay for the entire order' do
+      let(:store_credit) { create(:store_credit, amount: order_total) }
+      let(:order) { create(:order, user: store_credit.user, total: order_total) }
+
+      before do
+        subject
+        order.reload
+      end
+
+      it 'creates a store credit payment for the full amount' do
+        expect(order.payments.count).to eq 1
+        expect(order.payments.first).to be_store_credit
+        expect(order.payments.first.amount).to eq order_total
+      end
+    end
+
+    context 'the available store credit is not enough to pay for the entire order' do
+      let(:expected_cc_total) { 100.0 }
+      let(:store_credit_total) { order_total - expected_cc_total }
+      let(:store_credit) { create(:store_credit, amount: store_credit_total) }
+      let(:order) { create(:order, user: store_credit.user, total: order_total) }
+
+      before do
+        # callbacks recalculate total based on line items
+        # this ensures the total is what we expect
+        order.update_column(:total, order_total)
+        subject
+        order.reload
+      end
+
+      it 'creates a store credit payment for the available amount' do
+        expect(order.payments.count).to eq 1
+        expect(order.payments.first).to be_store_credit
+        expect(order.payments.first.amount).to eq store_credit_total
+      end
+    end
+
+    context 'there are multiple store credits' do
+      context 'they have different credit type priorities' do
+        let(:amount_difference) { 100 }
+        let!(:primary_store_credit) { create(:store_credit, amount: (order_total - amount_difference)) }
+        let!(:secondary_store_credit) do
+          create(:store_credit, amount: order_total, user: primary_store_credit.user,
+                                credit_type: create(:secondary_credit_type))
+        end
+        let(:order) { create(:order, user: primary_store_credit.user, total: order_total) }
+
+        before do
+          Timecop.scale(3600)
+          subject
+          order.reload
+        end
+
+        after { Timecop.return }
+
+        it 'uses the primary store credit type over the secondary' do
+          primary_payment = order.payments.first
+          secondary_payment = order.payments.last
+
+          expect(order.payments.size).to eq 2
+          expect(primary_payment.source).to eq primary_store_credit
+          expect(secondary_payment.source).to eq secondary_store_credit
+          expect(primary_payment.amount).to eq(order_total - amount_difference)
+          expect(secondary_payment.amount).to eq(amount_difference)
+        end
+      end
+    end
+  end
+
+  describe '#remove_store_credit_payments' do
+    subject { order.remove_store_credit_payments }
+
+    let(:order_total) { 500.00 }
+    let(:order) { create(:order, user: store_credit.user, total: order_total) }
+
+    context 'when order is not complete' do
+      let(:store_credit) { create(:store_credit, amount: order_total - 1) }
+
+      before do
+        create(:store_credit_payment_method)
+        order.add_store_credit_payments
+      end
+
+      it { expect { subject }.to change { order.payments.checkout.store_credits.count }.from(1).to(0) }
+      it { expect { subject }.to change { order.payments.with_state(:invalid).store_credits.count }.from(0).to(1) }
+    end
+
+    context 'when order is complete' do
+      let(:order) { create(:completed_order_with_store_credit_payment) }
+      let(:store_credit_payments) { order.payments.checkout.store_credits }
+
+      before do
+        subject
+        order.reload
+      end
+
+      it { expect(order.payments.checkout.store_credits).to eq store_credit_payments }
+    end
+  end
+
   describe '#covered_by_store_credit' do
     context "order doesn't have an associated user" do
       subject { create(:store_credits_order_without_user) }