spree_core 3.0.10 → 3.1.0.rc1

data/spec/models/spree/order_inventory_spec.rb

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
-describe Spree::OrderInventory, :type => :model do
+describe Spree::OrderInventory, type: :model do
   let(:order) { create :completed_order_with_totals }
   let(:line_item) { order.line_items.first }
 
   subject { described_class.new(order, line_item) }
 
+  describe 'delegate' do
+    it { is_expected.to delegate_method(:inventory_units).to(:line_item) }
+  end
+
   context "when order is missing inventory units" do
     before { line_item.update_column(:quantity, 2) }
 
@@ -91,9 +95,9 @@ describe Spree::OrderInventory, :type => :model do
     before do
       subject.verify
 
-      order.shipments.create(:stock_location_id => stock_location.id, :cost => 5)
+      order.shipments.create(stock_location_id: stock_location.id, cost: 5)
 
-      shipped = order.shipments.create(:stock_location_id => order.shipments.first.stock_location.id, :cost => 10)
+      shipped = order.shipments.create(stock_location_id: order.shipments.first.stock_location.id, cost: 10)
       shipped.update_column(:state, 'shipped')
     end
 
@@ -163,11 +167,13 @@ describe Spree::OrderInventory, :type => :model do
       end
 
       it 'should destroy backordered units first' do
-        allow(shipment).to receive_messages(inventory_units_for_item: [
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'backordered'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'backordered')
-        ])
+        allow(shipment).to receive_messages(
+          inventory_units_for_item: [
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'backordered', shipped?: false),
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'on_hand', shipped?: false),
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'backordered', shipped?: false)
+          ]
+        )
 
         expect(shipment.inventory_units_for_item[0]).to receive(:destroy)
         expect(shipment.inventory_units_for_item[1]).not_to receive(:destroy)
@@ -177,10 +183,12 @@ describe Spree::OrderInventory, :type => :model do
       end
 
       it 'should destroy unshipped units first' do
-        allow(shipment).to receive_messages(inventory_units_for_item: [
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'shipped'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand')
-        ])
+        allow(shipment).to receive_messages(
+          inventory_units_for_item: [
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'shipped', shipped?: true),
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'on_hand', shipped?: false)
+          ]
+        )
 
         expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
         expect(shipment.inventory_units_for_item[1]).to receive(:destroy)
@@ -189,10 +197,12 @@ describe Spree::OrderInventory, :type => :model do
       end
 
       it 'only attempts to destroy as many units as are eligible, and return amount destroyed' do
-        allow(shipment).to receive_messages(inventory_units_for_item: [
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'shipped'),
-          mock_model(Spree::InventoryUnit, :variant_id => variant.id, :state => 'on_hand')
-        ])
+        allow(shipment).to receive_messages(
+          inventory_units_for_item: [
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'shipped', shipped?: true),
+            mock_model(Spree::InventoryUnit, variant_id: variant.id, state: 'on_hand', shipped?: false)
+          ]
+        )
 
         expect(shipment.inventory_units_for_item[0]).not_to receive(:destroy)
         expect(shipment.inventory_units_for_item[1]).to receive(:destroy)
@@ -201,7 +211,7 @@ describe Spree::OrderInventory, :type => :model do
       end
 
       it 'should destroy self if not inventory units remain' do
-        allow(shipment.inventory_units).to receive_messages(:count => 0)
+        allow(shipment.inventory_units).to receive_messages(count: 0)
         expect(shipment).to receive(:destroy)
 
         expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)

data/spec/models/spree/order_spec.rb

@@ -15,6 +15,37 @@ describe Spree::Order, :type => :model do
     allow(Spree::LegacyUser).to receive_messages(:current => mock_model(Spree::LegacyUser, :id => 123))
   end
 
+  describe '.scopes' do
+    let!(:user) { FactoryGirl.create(:user) }
+    let!(:completed_order) { FactoryGirl.create(:order, user: user, completed_at: Time.current) }
+    let!(:incompleted_order) { FactoryGirl.create(:order, user: user, completed_at: nil) }
+
+    describe '.complete' do
+      it { expect(Spree::Order.complete).to include completed_order }
+      it { expect(Spree::Order.complete).not_to include incompleted_order }
+    end
+
+    describe '.incomplete' do
+      it { expect(Spree::Order.incomplete).to include incompleted_order }
+      it { expect(Spree::Order.incomplete).not_to include completed_order }
+    end
+  end
+
+  describe '#update_with_updater!' do
+    let(:updater) { Spree::OrderUpdater.new(order) }
+
+    before do
+      allow(order).to receive(:updater).and_return(updater)
+      allow(updater).to receive(:update).and_return(true)
+    end
+
+    after { order.update_with_updater! }
+
+    it 'expects to update order with order updater' do
+      expect(updater).to receive(:update).and_return(true)
+    end
+  end
+
   context "#cancel" do
     let(:order) { create(:completed_order_with_totals) }
     let!(:payment) do
@@ -157,9 +188,6 @@ describe Spree::Order, :type => :model do
     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(order).to receive :has_available_shipment
       allow(Spree::OrderMailer).to receive_message_chain :confirm_email, :deliver_later
       adjustments = [double]
       expect(order).to receive(:all_adjustments).and_return(adjustments)
@@ -203,15 +231,15 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  describe '#ensure_line_item_variants_are_not_deleted' do
-    subject { order.ensure_line_item_variants_are_not_deleted }
+  describe "#ensure_line_item_variants_are_not_discontinued" do
+    subject { order.ensure_line_item_variants_are_not_discontinued }
 
     let(:order) { create :order_with_line_items }
 
     context 'when variant is destroyed' do
       before do
         allow(order).to receive(:restart_checkout_flow)
-        order.line_items.first.variant.destroy
+        order.line_items.first.variant.discontinue!
       end
 
       it 'should restart checkout flow' do
@@ -221,7 +249,7 @@ describe Spree::Order, :type => :model do
 
       it 'should have error message' do
         subject
-        expect(order.errors[:base]).to include(Spree.t(:deleted_variants_present))
+        expect(order.errors[:base]).to include(Spree.t(:discontinued_variants_present))
       end
 
       it 'should be false' do
@@ -267,23 +295,37 @@ describe Spree::Order, :type => :model do
   end
 
   context "empty!" do
-    let(:order) { stub_model(Spree::Order, item_count: 2) }
+    let(:order) { Spree::Order.create(email: 'test@example.com') }
+    let(:promotion) { create :promotion, code: '10off' }
 
     before do
-      allow(order).to receive_messages(line_items: [1, 2])
-      allow(order).to receive_messages(adjustments: [])
-      allow(order).to receive_message_chain(:line_items, sum: 0)
+      promotion.orders << order
     end
 
-    it "clears out line items, adjustments and update totals" do
-      expect(order.line_items).to receive(:destroy_all)
-      expect(order.adjustments).to receive(:destroy_all)
-      expect(order.shipments).to receive(:destroy_all)
-      expect(order.updater).to receive(:update_totals)
-      expect(order.updater).to receive(:persist_totals)
+    context 'completed order' do
+      before do
+        order.update_columns(state: 'complete', completed_at: Time.current)
+      end
 
-      order.empty!
-      expect(order.item_total).to eq 0
+      it "raises an exception" do
+        expect { order.empty! }.to raise_error(RuntimeError, Spree.t(:cannot_empty_completed_order))
+      end
+    end
+
+    context 'incomplete order' do
+      before do
+        order.empty!
+      end
+
+      it "clears out line items, adjustments and update totals" do
+        expect(order.line_items.count).to be_zero
+        expect(order.adjustments.count).to be_zero
+        expect(order.shipments.count).to be_zero
+        expect(order.order_promotions.count).to be_zero
+        expect(order.promo_total).to be_zero
+        expect(order.item_total).to be_zero
+        expect(order.empty!).to eq(order)
+      end
     end
   end
 
@@ -392,7 +434,7 @@ describe Spree::Order, :type => :model do
     it "calls hook during update" do
       order = create(:order)
       expect(order).to receive(:add_awesome_sauce)
-      order.update!
+      order.update_with_updater!
     end
 
     it "calls hook during finalize" do
@@ -550,35 +592,6 @@ describe Spree::Order, :type => :model do
     end
   end
 
-  context "#generate_order_number" do
-    context "when no configure" do
-      let(:default_length) { 9 + 'R'.length }
-      subject(:order_number) { order.generate_number }
-      its(:class)  { should eq String }
-      its(:length) { should eq default_length }
-      it { should match /^R/ }
-    end
-
-    context "when length option is 5" do
-      let(:option_length) { 5 + 'R'.length }
-      it "should be option length for order number" do
-        expect(order.generate_number(length: 5).length).to eq option_length
-      end
-    end
-
-    context "when letters option is true" do
-      it "generates order number include letter" do
-        expect(order.generate_number(length: 100, letters: true)).to match /[A-Z]/
-      end
-    end
-
-    context "when prefix option is 'P'" do
-      it "generates order number and it prefix is 'P'" do
-        expect(order.generate_number(prefix: 'P')).to match /^P/
-      end
-    end
-  end
-
   describe "#associate_user!" do
     let(:user) { FactoryGirl.create(:user_with_addreses) }
     let(:email) { user.email }
@@ -746,7 +759,7 @@ describe Spree::Order, :type => :model do
       order.completed_at = nil
       expect(order.completed?).to be false
 
-      order.completed_at = Time.now
+      order.completed_at = Time.current
       expect(order.completed?).to be true
     end
   end
@@ -785,14 +798,14 @@ describe Spree::Order, :type => :model do
     it "should be false for completed order in the canceled state" do
       order.state = 'canceled'
       order.shipment_state = 'ready'
-      order.completed_at = Time.now
+      order.completed_at = Time.current
       expect(order.can_cancel?).to be false
     end
 
     it "should be true for completed order with no shipment" do
       order.state = 'complete'
       order.shipment_state = nil
-      order.completed_at = Time.now
+      order.completed_at = Time.current
       expect(order.can_cancel?).to be true
     end
   end

data/spec/models/spree/payment/gateway_options_spec.rb

@@ -8,7 +8,15 @@ RSpec.describe Spree::Payment::GatewayOptions, type: :model do
       Spree::Payment,
       order: order,
       number: "P1566",
-      currency: "EUR"
+      currency: "EUR",
+      payment_method: payment_method
+    )
+  end
+
+  let(:payment_method) do
+    double(
+      Spree::Gateway::Bogus,
+      exchange_multiplier: Spree::Gateway::FROM_DOLLAR_TO_CENT_RATE
     )
   end
 
@@ -31,6 +39,7 @@ RSpec.describe Spree::Payment::GatewayOptions, type: :model do
   let(:bill_address) do
     double Spree::Address, active_merchant_hash: { bill: :address }
   end
+
   let(:ship_address) do
     double Spree::Address, active_merchant_hash: { ship: :address }
   end
@@ -115,5 +124,4 @@ RSpec.describe Spree::Payment::GatewayOptions, type: :model do
     end
     it { should == expected }
   end
-
 end

data/spec/models/spree/payment/store_credit_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'Payment' do
+  context '#cancel!' do
+    subject { payment.cancel! }
+
+    context 'a store credit' do
+      let(:store_credit) { create(:store_credit, amount_used: captured_amount) }
+      let(:auth_code) { '1-SC-20141111111111' }
+      let(:captured_amount) { 10.0 }
+      let(:payment) { create(:store_credit_payment, response_code: auth_code) }
+
+      let!(:capture_event) do
+        create(:store_credit_auth_event,
+               action: Spree::StoreCredit::CAPTURE_ACTION,
+               authorization_code: auth_code,
+               amount: captured_amount,
+               store_credit: store_credit)
+      end
+
+      let(:successful_response) do
+        ActiveMerchant::Billing::Response.new(
+          true,
+          Spree.t('store_credit_payment_method.successful_action', action: :cancel),
+          {},
+          authorization: payment.response_code
+        )
+      end
+
+      let(:failed_response) do
+        ActiveMerchant::Billing::Response.new(
+          false,
+          Spree.t('store_credit_payment_method.unable_to_find_for_action', action: :cancel,
+                                                                           auth_code: payment.response_code),
+          {},
+          {}
+        )
+      end
+
+      it 'attemps to cancels the payment' do
+        expect(payment.payment_method).to receive(:cancel).with(payment.response_code) { successful_response }
+        subject
+      end
+
+      context 'cancels successfully' do
+        it 'voids the payment' do
+          expect { subject }.to change { payment.state }.to('void')
+        end
+      end
+
+      context 'does not cancel successfully' do
+        it 'does not change the payment state' do
+          expect(payment.payment_method).to receive(:cancel).with(payment.response_code) { failed_response }
+          expect { subject }.to raise_error(Spree::Core::GatewayError)
+          expect(payment.reload.state).not_to eq 'void'
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/payment_method/store_credit_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+describe Spree::PaymentMethod::StoreCredit do
+  let(:order) { create(:order) }
+  let(:payment) { create(:payment, order: order) }
+  let(:gateway_options) { payment.gateway_options }
+
+  context '#authorize' do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.authorize(auth_amount, store_credit, gateway_options)
+    end
+
+    let(:auth_amount) { store_credit.amount_remaining * 100 }
+    let(:store_credit) { create(:store_credit) }
+    let(:gateway_options) { super().merge(originator: originator) }
+    let(:originator) { nil }
+
+    context 'without an invalid store credit' do
+      let(:store_credit) { nil }
+      let(:auth_amount) { 10 }
+
+      it 'declines an unknown store credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.unable_to_find')
+      end
+    end
+
+    context 'with insuffient funds' do
+      let(:auth_amount) { (store_credit.amount_remaining * 100) + 1 }
+
+      it 'declines a store credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.insufficient_funds')
+      end
+    end
+
+    context 'when the currency does not match the order currency' do
+      let(:store_credit) { create(:store_credit, currency: 'AUD') }
+
+      it 'declines the credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.currency_mismatch')
+      end
+    end
+
+    context 'with a valid request' do
+      it 'authorizes a valid store credit' do
+        expect(subject.success?).to be true
+        expect(subject.authorization).to_not be_nil
+      end
+
+      context 'with an originator' do
+        let(:originator) { double('originator') }
+
+        it 'passes the originator' do
+          expect_any_instance_of(Spree::StoreCredit).to receive(:authorize).
+            with(anything, anything, action_originator: originator)
+          subject
+        end
+      end
+    end
+  end
+
+  context '#capture' do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.capture(capture_amount, auth_code, gateway_options)
+    end
+
+    let(:capture_amount) { 10_00 }
+    let(:auth_code) { auth_event.authorization_code }
+    let(:gateway_options) { super().merge(originator: originator) }
+
+    let(:authorized_amount) { capture_amount / 100.0 }
+    let(:auth_event) { create(:store_credit_auth_event, store_credit: store_credit, amount: authorized_amount) }
+    let(:store_credit) { create(:store_credit, amount_authorized: authorized_amount) }
+    let(:originator) { nil }
+
+    context 'with an invalid auth code' do
+      let(:auth_code) { -1 }
+
+      it 'declines an unknown store credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.unable_to_find')
+      end
+    end
+
+    context 'when unable to authorize the amount' do
+      let(:authorized_amount) { (capture_amount - 1) / 100 }
+
+      before do
+        allow_any_instance_of(Spree::StoreCredit).to receive_messages(authorize: true)
+      end
+
+      it 'declines a store credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.insufficient_authorized_amount')
+      end
+    end
+
+    context 'when the currency does not match the order currency' do
+      let(:store_credit) { create(:store_credit, currency: 'AUD', amount_authorized: authorized_amount) }
+
+      it 'declines the credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.currency_mismatch')
+      end
+    end
+
+    context 'with a valid request' do
+      it 'captures the store credit' do
+        expect(subject.message).to include Spree.t('store_credit_payment_method.successful_action',
+                                                   action: Spree::StoreCredit::CAPTURE_ACTION)
+        expect(subject.success?).to be true
+      end
+
+      context 'with an originator' do
+        let(:originator) { double('originator') }
+
+        it 'passes the originator' do
+          expect_any_instance_of(Spree::StoreCredit).to receive(:capture).
+            with(anything, anything, anything, action_originator: originator)
+          subject
+        end
+      end
+    end
+  end
+
+  context '#void' do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.void(auth_code, gateway_options)
+    end
+
+    let(:auth_code) { auth_event.authorization_code }
+    let(:gateway_options) { super().merge(originator: originator) }
+    let(:auth_event) { create(:store_credit_auth_event) }
+    let(:originator) { nil }
+
+    context 'with an invalid auth code' do
+      let(:auth_code) { 1 }
+
+      it 'declines an unknown store credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.unable_to_find')
+      end
+    end
+
+    context 'when the store credit is not voided successfully' do
+      before { allow_any_instance_of(Spree::StoreCredit).to receive(:void).and_return false }
+
+      it 'returns an error response' do
+        expect(subject.success?).to be false
+      end
+    end
+
+    it 'voids a valid store credit void request' do
+      expect(subject.success?).to be true
+      expect(subject.message).to include Spree.t('store_credit_payment_method.successful_action',
+                                                 action: Spree::StoreCredit::VOID_ACTION)
+    end
+
+    context 'with an originator' do
+      let(:originator) { double('originator') }
+
+      it 'passes the originator' do
+        expect_any_instance_of(Spree::StoreCredit).to receive(:void).with(anything, action_originator: originator)
+        subject
+      end
+    end
+  end
+
+  context '#purchase' do
+    it "declines a purchase if it can't find a pending credit for the correct amount" do
+      amount = 100.0
+      store_credit = create(:store_credit)
+      auth_code = store_credit.generate_authorization_code
+      store_credit.store_credit_events.create!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
+                                               amount: amount,
+                                               authorization_code: auth_code)
+      store_credit.store_credit_events.create!(action: Spree::StoreCredit::CAPTURE_ACTION,
+                                               amount: amount, authorization_code: auth_code)
+
+      response = subject.purchase(amount * 100.0, store_credit, gateway_options)
+      expect(response.success?).to be false
+      expect(response.message).to include Spree.t('store_credit_payment_method.unable_to_find')
+    end
+
+    it 'captures a purchase if it can find a pending credit for the correct amount' do
+      amount = 100.0
+      store_credit = create(:store_credit)
+      auth_code = store_credit.generate_authorization_code
+      store_credit.store_credit_events.create!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
+                                               amount: amount, authorization_code: auth_code)
+
+      response = subject.purchase(amount * 100.0, store_credit, gateway_options)
+      expect(response.success?).to be true
+      expect(response.message).to include Spree.t('store_credit_payment_method.successful_action',
+                                                  action: Spree::StoreCredit::CAPTURE_ACTION)
+    end
+  end
+
+  context '#credit' do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.credit(credit_amount, auth_code, gateway_options)
+    end
+
+    let(:credit_amount) { 100.0 }
+    let(:auth_code) { auth_event.authorization_code }
+    let(:gateway_options) { super().merge(originator: originator) }
+    let(:auth_event) { create(:store_credit_auth_event) }
+    let(:originator) { nil }
+
+    context 'with an invalid auth code' do
+      let(:auth_code) { 1 }
+
+      it 'declines an unknown store credit' do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit_payment_method.unable_to_find')
+      end
+    end
+
+    context "when the store credit isn't credited successfully" do
+      before { allow(Spree::StoreCredit).to receive_messages(credit: false) }
+
+      it 'returns an error response' do
+        expect(subject.success?).to be false
+      end
+    end
+
+    context 'with a valid credit request' do
+      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(credit: true) }
+
+      it 'credits a valid store credit credit request' do
+        expect(subject.success?).to be true
+        expect(subject.message).to include Spree.t('store_credit_payment_method.successful_action',
+                                                   action: Spree::StoreCredit::CREDIT_ACTION)
+      end
+    end
+
+    context 'with an originator' do
+      let(:originator) { double('originator') }
+
+      it 'passes the originator' do
+        allow_any_instance_of(Spree::StoreCredit).to receive(:credit).
+          with(anything, anything, anything, action_originator: originator)
+        subject
+      end
+    end
+  end
+
+  context '#cancel' do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.cancel(auth_code)
+    end
+
+    let(:store_credit) { create(:store_credit, amount_used: captured_amount) }
+    let(:auth_code) { '1-SC-20141111111111' }
+    let(:captured_amount) { 10.0 }
+
+    let!(:capture_event) do
+      create(:store_credit_auth_event,
+             action: Spree::StoreCredit::CAPTURE_ACTION,
+             authorization_code: auth_code,
+             amount: captured_amount,
+             store_credit: store_credit)
+    end
+
+    context 'store credit event found' do
+      it 'creates a store credit for the same amount that was captured' do
+        allow_any_instance_of(Spree::StoreCredit).to receive(:credit).
+          with(captured_amount, auth_code, store_credit.currency)
+        subject
+      end
+
+      it 'returns a valid store credit cancel request' do
+        expect(subject.success?).to be true
+        expect(subject.message).to include Spree.t('store_credit_payment_method.successful_action',
+                                                   action: Spree::StoreCredit::CANCEL_ACTION)
+      end
+    end
+
+    context 'store credit event not found' do
+      subject do
+        Spree::PaymentMethod::StoreCredit.new.cancel('INVALID')
+      end
+
+      it 'returns an error response' do
+        expect(subject.success?).to be false
+      end
+    end
+  end
+end