spree_core 3.3.0.rc1 → 3.3.0.rc2

data/spec/models/spree/stock_location_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe StockLocation, type: :model do
-    subject { create(:stock_location_with_items, backorderable_default: true) }
-    let(:stock_item) { subject.stock_items.order(:id).first }
-    let(:variant) { stock_item.variant }
-
-    it 'creates stock_items for all variants' do
-      expect(subject.stock_items.count).to eq Variant.count
-    end
-
-    context "handling stock items" do
-      let!(:variant) { create(:variant) }
-
-      context "given a variant" do
-        subject { StockLocation.create(name: "testing", propagate_all_variants: false) }
-
-        context "set up" do
-          it "creates stock item" do
-            expect(subject).to receive(:propagate_variant)
-            subject.set_up_stock_item(variant)
-          end
-
-          context "stock item exists" do
-            let!(:stock_item) { subject.propagate_variant(variant) }
-
-            it "returns existing stock item" do
-              expect(subject.set_up_stock_item(variant)).to eq(stock_item)
-            end
-          end
-        end
-
-        context "propagate variants" do
-          let(:stock_item) { subject.propagate_variant(variant) }
-
-          it "creates a new stock item" do
-            expect {
-              subject.propagate_variant(variant)
-            }.to change{ StockItem.count }.by(1)
-          end
-
-          context "passes backorderable default config" do
-            context "true" do
-              before { subject.backorderable_default = true }
-              it { expect(stock_item.backorderable).to be true }
-            end
-
-            context "false" do
-              before { subject.backorderable_default = false }
-              it { expect(stock_item.backorderable).to be false }
-            end
-          end
-        end
-
-        context "propagate all variants" do
-          subject { StockLocation.new(name: "testing") }
-
-          context "true" do
-            before { subject.propagate_all_variants = true }
-
-            specify do
-              expect(subject).to receive(:propagate_variant).at_least(:once)
-              subject.save!
-            end
-          end
-
-          context "false" do
-            before { subject.propagate_all_variants = false }
-
-            specify do
-              expect(subject).not_to receive(:propagate_variant)
-              subject.save!
-            end
-          end
-        end
-      end
-    end
-
-    it 'finds a stock_item for a variant' do
-      stock_item = subject.stock_item(variant)
-      expect(stock_item.count_on_hand).to eq 10
-    end
-
-    it 'finds a stock_item for a variant by id' do
-      stock_item = subject.stock_item(variant.id)
-      expect(stock_item.variant).to eq variant
-    end
-
-    it 'returns nil when stock_item is not found for variant' do
-      stock_item = subject.stock_item(100)
-      expect(stock_item).to be_nil
-    end
-
-    describe '#stock_item_or_create' do
-      before do
-        variant = create(:variant)
-        variant.stock_items.destroy_all
-        variant.save
-      end
-
-      it 'creates a stock_item if not found for a variant' do
-        stock_item = subject.stock_item_or_create(variant)
-        expect(stock_item.variant).to eq variant
-      end
-    end
-
-    it 'finds a count_on_hand for a variant' do
-       expect(subject.count_on_hand(variant)).to eq 10
-    end
-
-    it 'finds determines if you a variant is backorderable' do
-      expect(subject.backorderable?(variant)).to be true
-    end
-
-    it 'restocks a variant with a positive stock movement' do
-      originator = double
-      expect(subject).to receive(:move).with(variant, 5, originator)
-      subject.restock(variant, 5, originator)
-    end
-
-    it 'unstocks a variant with a negative stock movement' do
-      originator = double
-      expect(subject).to receive(:move).with(variant, -5, originator)
-      subject.unstock(variant, 5, originator)
-    end
-
-    it 'it creates a stock_movement' do
-      expect {
-        subject.move variant, 5
-      }.to change { subject.stock_movements.where(stock_item_id: stock_item).count }.by(1)
-    end
-
-    it 'can be deactivated' do
-      create(:stock_location, active: true)
-      create(:stock_location, active: false)
-      expect(Spree::StockLocation.active.count).to eq 1
-    end
-
-    it 'ensures only one stock location is default at a time' do
-      first = create(:stock_location, active: true, default: true)
-      second = create(:stock_location, active: true, default: true)
-
-      expect(first.reload.default).to eq false
-      expect(second.reload.default).to eq true
-
-      first.default = true
-      first.save!
-
-      expect(first.reload.default).to eq true
-      expect(second.reload.default).to eq false
-    end
-
-    context 'fill_status' do
-      it 'all on_hand with no backordered' do
-        on_hand, backordered = subject.fill_status(variant, 5)
-        expect(on_hand).to eq 5
-        expect(backordered).to eq 0
-      end
-
-      it 'some on_hand with some backordered' do
-        on_hand, backordered = subject.fill_status(variant, 20)
-        expect(on_hand).to eq 10
-        expect(backordered).to eq 10
-      end
-
-      it 'zero on_hand with all backordered' do
-        zero_stock_item = mock_model(StockItem,
-                                     count_on_hand: 0,
-                                     backorderable?: true)
-        expect(subject).to receive(:stock_item).with(variant).and_return(zero_stock_item)
-
-        on_hand, backordered = subject.fill_status(variant, 20)
-        expect(on_hand).to eq 0
-        expect(backordered).to eq 20
-      end
-
-      context 'when backordering is not allowed' do
-        before do
-          @stock_item = mock_model(StockItem, backorderable?: false)
-          expect(subject).to receive(:stock_item).with(variant).and_return(@stock_item)
-        end
-
-        it 'all on_hand' do
-          allow(@stock_item).to receive_messages(count_on_hand: 10)
-
-          on_hand, backordered = subject.fill_status(variant, 5)
-          expect(on_hand).to eq 5
-          expect(backordered).to eq 0
-        end
-
-        it 'some on_hand' do
-          allow(@stock_item).to receive_messages(count_on_hand: 10)
-
-          on_hand, backordered = subject.fill_status(variant, 20)
-          expect(on_hand).to eq 10
-          expect(backordered).to eq 0
-        end
-
-        it 'zero on_hand' do
-          allow(@stock_item).to receive_messages(count_on_hand: 0)
-
-          on_hand, backordered = subject.fill_status(variant, 20)
-          expect(on_hand).to eq 0
-          expect(backordered).to eq 0
-        end
-      end
-
-      context 'without stock_items' do
-        subject { create(:stock_location) }
-        let(:variant) { create(:base_variant) }
-
-        it 'zero on_hand and backordered' do
-          subject
-          variant.stock_items.destroy_all
-          on_hand, backordered = subject.fill_status(variant, 1)
-          expect(on_hand).to eq 0
-          expect(backordered).to eq 0
-        end
-      end
-    end
-
-    context '#state_text' do
-      context 'state is blank' do
-        subject { StockLocation.create(name: "testing", state: nil, state_name: 'virginia') }
-        specify { expect(subject.state_text).to eq('virginia') }
-      end
-
-      context 'both name and abbr is present' do
-        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: 'va') }
-        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
-        specify { expect(subject.state_text).to eq('va') }
-      end
-
-      context 'only name is present' do
-        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: nil) }
-        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
-        specify { expect(subject.state_text).to eq('virginia') }
-      end
-    end
-
-  end
-end

data/spec/models/spree/stock_movement_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe Spree::StockMovement, type: :model do
-
-  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
-
-  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
-
-  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
-    end
-  end
-
-  describe 'Callbacks' do
-    it { is_expected.to callback(:update_stock_item_quantity).after(:create) }
-  end
-
-  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
-
-  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
-end

data/spec/models/spree/stock_transfer_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  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 }
-    let(:variant) { stock_item.variant }
-
-    subject { StockTransfer.create(reference: 'PO123') }
-
-    describe '#reference' do
-      subject { super().reference }
-      it { is_expected.to eq 'PO123' }
-    end
-
-    describe '#to_param' do
-      subject { super().to_param }
-      it { is_expected.to match /T\d+/ }
-    end
-
-    it 'transfers variants between 2 locations' do
-      variants = { variant => 5 }
-
-      subject.transfer(source_location,
-                       destination_location,
-                       variants)
-
-      expect(source_location.count_on_hand(variant)).to eq 5
-      expect(destination_location.count_on_hand(variant)).to eq 5
-
-      expect(subject.source_location).to eq source_location
-      expect(subject.destination_location).to eq destination_location
-
-      expect(subject.source_movements.first.quantity).to eq -5
-      expect(subject.destination_movements.first.quantity).to eq 5
-    end
-
-    it 'receive new inventory (from a vendor)' do
-      variants = { variant => 5 }
-
-      subject.receive(destination_location, variants)
-
-      expect(destination_location.count_on_hand(variant)).to eq 5
-
-      expect(subject.source_location).to be_nil
-      expect(subject.destination_location).to eq destination_location
-    end
-  end
-end

data/spec/models/spree/store_credit_event_spec.rb

@@ -1,101 +0,0 @@
-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