spree_core 3.0.9 → 3.2.0

data/spec/models/spree/stock_movement_spec.rb

@@ -1,55 +1,119 @@
 require 'spec_helper'
 
-describe Spree::StockMovement, :type => :model do
-  let(:stock_location) { create(:stock_location_with_items) }
-  let(:stock_item) { stock_location.stock_items.order(:id).first }
-  subject { build(:stock_movement, stock_item: stock_item) }
+describe Spree::StockMovement, type: :model do
 
-  it 'should belong to a stock item' do
-    expect(subject).to respond_to(:stock_item)
+  describe 'Constants' do
+    describe 'QUANTITY_LIMITS[:max]' do
+      it 'return 2**31 - 1' do
+        expect(Spree::StockMovement::QUANTITY_LIMITS[:max]).to eq(2**31 - 1)
+      end
+    end
+
+    describe 'QUANTITY_LIMITS[:min]' do
+      it 'return -2**31' do
+        expect(Spree::StockMovement::QUANTITY_LIMITS[:min]).to eq(-2**31)
+      end
+    end
   end
 
-  it 'is readonly unless new' do
-    subject.save
-    expect {
-      subject.save
-    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  describe 'Associations' do
+    it { is_expected.to belong_to(:stock_item).class_name('Spree::StockItem').inverse_of(:stock_movements) }
+    it { is_expected.to belong_to(:originator) }
   end
 
-  it 'does not update count on hand when track inventory levels is false' do
-    Spree::Config[:track_inventory_levels] = false
-    subject.quantity = 1
-    subject.save
-    stock_item.reload
-    expect(stock_item.count_on_hand).to eq(10)
+  describe 'Validations' do
+    it do
+      is_expected.to validate_presence_of(:stock_item)
+    end
+
+    it do
+      is_expected.to validate_presence_of(:quantity)
+    end
+
+    it do
+      is_expected.to validate_numericality_of(:quantity).
+        is_greater_than_or_equal_to(Spree::StockMovement::QUANTITY_LIMITS[:min]).
+        is_less_than_or_equal_to(Spree::StockMovement::QUANTITY_LIMITS[:max]).only_integer.allow_nil
+    end
   end
 
-  it 'does not update count on hand when variant inventory tracking is off' do
-    stock_item.variant.track_inventory = false
-    subject.quantity = 1
-    subject.save
-    stock_item.reload
-    expect(stock_item.count_on_hand).to eq(10)
+  describe 'Callbacks' do
+    it { is_expected.to callback(:update_stock_item_quantity).after(:create) }
   end
 
-  context "when quantity is negative" do
-    context "after save" do
-      it "should decrement the stock item count on hand" do
-        subject.quantity = -1
-        subject.save
-        stock_item.reload
-        expect(stock_item.count_on_hand).to eq(9)
+  describe 'Scope' do
+    describe '.recent' do
+      it 'should order chronologically by created at' do
+        expect(Spree::StockMovement.recent.to_sql).
+          to eq Spree::StockMovement.unscoped.order(created_at: :desc).to_sql
       end
     end
   end
 
-  context "when quantity is positive" do
-    context "after save" do
-      it "should increment the stock item count on hand" do
-        subject.quantity = 1
-        subject.save
-        stock_item.reload
-        expect(stock_item.count_on_hand).to eq(11)
+  describe 'whitelisted ransackable attributes' do
+    it 'returns amount attribute' do
+      expect(Spree::StockMovement.whitelisted_ransackable_attributes).to eq(['quantity'])
+    end
+  end
+
+  describe 'Insatance Methods' do
+    let(:stock_location) { create(:stock_location_with_items) }
+    let(:stock_item) { stock_location.stock_items.order(:id).first }
+
+    describe '#readonly?' do
+      let(:stock_movement) { create(:stock_movement, stock_item: stock_item) }
+      it 'should not update a persisted record' do
+        expect { stock_movement.save }.to raise_error(ActiveRecord::ReadOnlyRecord)
+      end
+    end
+
+    describe '#update_stock_item_quantity' do
+      let(:stock_movement) { build(:stock_movement, stock_item: stock_item) }
+
+      context 'when track inventory levels is false' do
+        before do
+          Spree::Config[:track_inventory_levels] = false
+          stock_movement.quantity = 1
+          stock_movement.save
+          stock_item.reload
+        end
+        it 'does not update count on hand' do
+          expect(stock_item.count_on_hand).to eq(10)
+        end
+      end
+
+      context 'when track inventory tracking is off' do
+        before do
+          stock_item.variant.track_inventory = false
+          stock_movement.quantity = 1
+          stock_movement.save
+          stock_item.reload
+        end
+        it 'does not update count on hand' do
+          expect(stock_item.count_on_hand).to eq(10)
+        end
+      end
+
+      context 'when quantity is negative' do
+        before do
+          stock_movement.quantity = -1
+          stock_movement.save
+          stock_item.reload
+        end
+        it 'should decrement the stock item count on hand' do
+          expect(stock_item.count_on_hand).to eq(9)
+        end
+      end
+
+      context "when quantity is positive" do
+        before do
+          stock_movement.quantity = 1
+          stock_movement.save
+          stock_item.reload
+        end
+        it "should increment the stock item count on hand" do
+          expect(stock_item.count_on_hand).to eq(11)
+        end
       end
     end
   end

data/spec/models/spree/stock_transfer_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe StockTransfer, :type => :model do
+  describe StockTransfer, type: :model do
     let(:destination_location) { create(:stock_location_with_items) }
     let(:source_location) { create(:stock_location_with_items) }
     let(:stock_item) { source_location.stock_items.order(:id).first }

data/spec/models/spree/store_credit_event_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe 'StoreCreditEvent' do
+  describe '#display_amount' do
+    let(:event_amount) { 120.0 }
+
+    subject { create(:store_credit_auth_event, amount: event_amount) }
+
+    it 'returns a Spree::Money instance' do
+      expect(subject.display_amount).to be_instance_of(Spree::Money)
+    end
+
+    it 'uses the events amount attribute' do
+      expect(subject.display_amount).to eq Spree::Money.new(event_amount, currency: subject.currency)
+    end
+  end
+
+  describe '#display_user_total_amount' do
+    let(:user_total_amount) { 300.0 }
+
+    subject { create(:store_credit_auth_event, user_total_amount: user_total_amount) }
+
+    it 'returns a Spree::Money instance' do
+      expect(subject.display_user_total_amount).to be_instance_of(Spree::Money)
+    end
+
+    it 'uses the events user_total_amount attribute' do
+      amount = Spree::Money.new(user_total_amount, currency: subject.currency)
+      expect(subject.display_user_total_amount).to eq amount
+    end
+  end
+
+  describe '#display_action' do
+    subject { create(:store_credit_auth_event, action: action) }
+
+    context 'capture event' do
+      let(:action) { Spree::StoreCredit::CAPTURE_ACTION }
+
+      it 'returns used' do
+        expect(subject.display_action).to eq Spree.t('store_credit.captured')
+      end
+    end
+
+    context 'authorize event' do
+      let(:action) { Spree::StoreCredit::AUTHORIZE_ACTION }
+
+      it 'returns authorized' do
+        expect(subject.display_action).to eq Spree.t('store_credit.authorized')
+      end
+    end
+
+    context 'allocation event' do
+      let(:action) { Spree::StoreCredit::ALLOCATION_ACTION }
+
+      it 'returns added' do
+        expect(subject.display_action).to eq Spree.t('store_credit.allocated')
+      end
+    end
+
+    context 'void event' do
+      let(:action) { Spree::StoreCredit::VOID_ACTION }
+
+      it 'returns credit' do
+        expect(subject.display_action).to eq Spree.t('store_credit.credit')
+      end
+    end
+
+    context 'credit event' do
+      let(:action) { Spree::StoreCredit::CREDIT_ACTION }
+
+      it 'returns credit' do
+        expect(subject.display_action).to eq Spree.t('store_credit.credit')
+      end
+    end
+  end
+
+  describe '#order' do
+    context 'there is no associated payment with the event' do
+      subject { create(:store_credit_auth_event) }
+
+      it 'returns nil' do
+        expect(subject.order).to be_nil
+      end
+    end
+
+    context 'there is an associated payment with the event' do
+      let(:authorization_code) { '1-SC-TEST' }
+      let(:order) { create(:order) }
+      let!(:payment) { create(:store_credit_payment, order: order, response_code: authorization_code) }
+
+      subject do
+        create(:store_credit_auth_event, action: Spree::StoreCredit::CAPTURE_ACTION,
+                                         authorization_code: authorization_code)
+      end
+
+      it 'returns the order associated with the payment' do
+        expect(subject.order).to eq order
+      end
+    end
+  end
+end