solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/stock_location_spec.rb

@@ -1,279 +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
-
-      it 'creates a stock_item if not found for a variant_id' do
-        stock_item = subject.stock_item_or_create(variant.id)
-        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
-
-
-    describe "#move" do
-      let!(:variant) { create(:variant) }
-      def move
-        subject.move(variant, quantity)
-      end
-
-      context "no stock item exists" do
-        before { subject.stock_items.destroy_all }
-        context "positive movement" do
-          let(:quantity) { 1 }
-          it "creates a stock item" do
-            expect { move }.to change { subject.stock_items.count }.by 1
-          end
-        end
-
-        # We should not be creating stock items that do not exist
-        # for the sake of a negative movement.
-        context "negative movement" do
-          let(:quantity) { -1 }
-          it "raises an error" do
-            expect {
-              expect {
-                move
-              }.to raise_error StockLocation::InvalidMovementError
-            }.not_to change { subject.stock_items.count }
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/models/spree/stock_movement_spec.rb

@@ -1,56 +0,0 @@
-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) }
-
-  it 'should belong to a stock item' do
-    expect(subject).to respond_to(:stock_item)
-  end
-
-  it 'is readonly unless new' do
-    subject.save
-    expect {
-      subject.save
-    }.to raise_error(ActiveRecord::ReadOnlyRecord)
-  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)
-  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)
-  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)
-      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)
-      end
-    end
-  end
-end

data/spec/models/spree/stock_transfer_spec.rb

@@ -1,290 +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 }
-    let(:stock_transfer) do
-      StockTransfer.create(description: 'PO123', source_location: source_location, destination_location: destination_location)
-    end
-
-    subject { stock_transfer }
-
-    describe '#description' do
-      subject { super().description }
-      it { is_expected.to eq 'PO123' }
-    end
-
-    describe '#to_param' do
-      subject { super().to_param }
-      it { is_expected.to match /T\d+/ }
-    end
-
-    describe "transfer item building" do
-      let(:stock_transfer) do
-        variant = source_location.stock_items.first.variant
-        stock_transfer = Spree::StockTransfer.new(
-          number: "T123",
-          source_location: source_location,
-          destination_location: destination_location
-        )
-        stock_transfer.transfer_items.build(variant: variant, expected_quantity: 5)
-        stock_transfer
-      end
-
-      subject { stock_transfer.save }
-
-      it { is_expected.to eq true }
-
-      it "creates the associated transfer item" do
-        expect { subject }.to change { Spree::TransferItem.count }.by(1)
-      end
-    end
-
-    describe "#receivable?" do
-      subject { stock_transfer.receivable? }
-
-      context "finalized" do
-        before do
-          stock_transfer.update_attributes(finalized_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "shipped" do
-        before do
-          stock_transfer.update_attributes(shipped_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "closed" do
-        before do
-          stock_transfer.update_attributes(closed_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "finalized and closed" do
-        before do
-          stock_transfer.update_attributes(finalized_at: Time.now, closed_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "shipped and closed" do
-        before do
-          stock_transfer.update_attributes(shipped_at: Time.now, closed_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "finalized and shipped" do
-        before do
-          stock_transfer.update_attributes(finalized_at: Time.now, shipped_at: Time.now)
-        end
-
-        it { is_expected.to eq true }
-      end
-    end
-
-    describe "#finalizable?" do
-      subject { stock_transfer.finalizable? }
-
-      context "finalized" do
-        before do
-          stock_transfer.update_attributes(finalized_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "shipped" do
-        before do
-          stock_transfer.update_attributes(shipped_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "closed" do
-        before do
-          stock_transfer.update_attributes(closed_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "finalized and closed" do
-        before do
-          stock_transfer.update_attributes(finalized_at: Time.now, closed_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "shipped and closed" do
-        before do
-          stock_transfer.update_attributes(shipped_at: Time.now, closed_at: Time.now)
-        end
-
-        it { is_expected.to eq false }
-      end
-
-      context "no action taken on stock transfer" do
-        before do
-          stock_transfer.update_attributes(finalized_at: nil, shipped_at: nil, closed_at: nil)
-        end
-
-        it { is_expected.to eq true }
-      end
-    end
-
-    describe "#finalize" do
-      let(:user) { create(:user) }
-
-      subject { stock_transfer.finalize(user) }
-
-      context "can be finalized" do
-        it "sets a finalized_at date" do
-          expect { subject }.to change { stock_transfer.finalized_at }
-        end
-
-        it "sets the finalized_by to the supplied user" do
-          subject
-          expect(stock_transfer.finalized_by).to eq user
-        end
-      end
-
-      context "can't be finalized" do
-        before do
-          stock_transfer.update_attributes(finalized_at: Time.now)
-        end
-
-        it "doesn't set a finalized_at date" do
-          expect { subject }.to_not change { stock_transfer.finalized_at }
-        end
-
-        it "doesn't set a finalized_by user" do
-          expect { subject }.to_not change { stock_transfer.finalized_by }
-        end
-
-        it "adds an error message" do
-          subject
-          expect(stock_transfer.errors.full_messages).to include Spree.t(:stock_transfer_cannot_be_finalized)
-        end
-      end
-    end
-
-    describe "#close" do
-      let(:user) { create(:user) }
-      let(:stock_transfer) { create(:receivable_stock_transfer_with_items) }
-
-      subject { stock_transfer.close(user) }
-
-      context "can be closed" do
-        it "sets a closed_at date" do
-          expect { subject }.to change { stock_transfer.closed_at }
-        end
-
-        it "sets the closed_by to the supplied user" do
-          subject
-          expect(stock_transfer.closed_by).to eq user
-        end
-      end
-
-      context "can't be closed" do
-        before do
-          stock_transfer.update_attributes(finalized_at: nil)
-        end
-
-        it "doesn't set a closed_at date" do
-          expect { subject }.to_not change { stock_transfer.closed_at }
-        end
-
-        it "doesn't set a closed_by user" do
-          expect { subject }.to_not change { stock_transfer.closed_by }
-        end
-
-        it "adds an error message" do
-          subject
-          expect(stock_transfer.errors.full_messages).to include Spree.t(:stock_transfer_must_be_receivable)
-        end
-      end
-    end
-
-    describe "destroying" do
-      subject { stock_transfer.destroy }
-
-      context "stock transfer is finalized" do
-        before do
-          stock_transfer.update_attributes!(finalized_at: Time.now)
-        end
-
-        it "doesn't destroy the stock transfer" do
-          expect { subject }.to_not change { Spree::StockTransfer.count }
-        end
-
-        it "adds an error message to the model" do
-          subject
-          expect(stock_transfer.errors.full_messages).to include Spree.t('errors.messages.cannot_delete_finalized_stock_transfer')
-        end
-      end
-
-      context "stock transfer is not finalized" do
-        before do
-          stock_transfer.update_attributes!(finalized_at: nil)
-        end
-
-        it "destroys the stock transfer" do
-          expect { subject }.to change { Spree::StockTransfer.count }.by(-1)
-        end
-      end
-    end
-
-    describe '#transfer' do
-      let(:stock_transfer) { create(:stock_transfer_with_items) }
-
-      before do
-        stock_transfer.transfer_items.each { |item| item.update_attributes(expected_quantity: 1) }
-      end
-
-      subject { stock_transfer.transfer }
-
-      context 'with enough stock' do
-
-        it 'creates stock movements for transfer items' do
-          expect{ subject }.to change{ Spree::StockMovement.count }.by(stock_transfer.transfer_items.count)
-        end
-      end
-
-      context 'without enough stock' do
-        before do
-          stockless_variant = stock_transfer.transfer_items.last.variant
-          stock_transfer.source_location.stock_item(stockless_variant).set_count_on_hand(0)
-        end
-
-        it 'rollsback the transaction' do
-          expect{ subject }.to_not change{ Spree::StockMovement.count }
-        end
-
-        it 'adds errors' do
-          subject
-          expect(stock_transfer.errors.full_messages.join(', ')).to match /not enough inventory/
-        end
-
-        it 'returns false' do
-          expect(subject).to eq false
-        end
-
-      end
-    end
-  end
-end