solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/stock/prioritizer_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Prioritizer, :type => :model do
-      let(:order) { mock_model(Order) }
-      let(:stock_location) { build(:stock_location) }
-      let(:variant) { build(:variant) }
-
-      def inventory_units
-        @inventory_units ||= []
-      end
-
-      def build_inventory_unit
-        mock_model(InventoryUnit, variant: variant).tap do |unit|
-          inventory_units << unit
-        end
-      end
-
-      def pack
-        package = Package.new(order)
-        yield(package) if block_given?
-        package
-      end
-
-      it 'keeps a single package' do
-        package1 = pack do |package|
-          package.add build_inventory_unit
-          package.add build_inventory_unit
-        end
-
-        packages = [package1]
-        prioritizer = Prioritizer.new(inventory_units, packages)
-        packages = prioritizer.prioritized_packages
-        expect(packages.size).to eq 1
-      end
-
-      it 'removes duplicate packages' do
-        package1 = pack do |package|
-          package.add build_inventory_unit
-          package.add build_inventory_unit
-        end
-
-        package2 = pack do |package|
-          package.add inventory_units.first
-          package.add inventory_units.last
-        end
-
-        packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
-        packages = prioritizer.prioritized_packages
-        expect(packages.size).to eq 1
-      end
-
-      it 'split over 2 packages' do
-        package1 = pack do |package|
-          package.add build_inventory_unit
-        end
-        package2 = pack do |package|
-          package.add build_inventory_unit
-        end
-
-        packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
-        packages = prioritizer.prioritized_packages
-        expect(packages.size).to eq 2
-      end
-
-      it '1st has some, 2nd has remaining' do
-        5.times { build_inventory_unit }
-
-        package1 = pack do |package|
-          2.times { |i| package.add inventory_units[i] }
-        end
-        package2 = pack do |package|
-          5.times { |i| package.add inventory_units[i] }
-        end
-
-        packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
-        packages = prioritizer.prioritized_packages
-        expect(packages.count).to eq 2
-        expect(packages[0].quantity).to eq 2
-        expect(packages[1].quantity).to eq 3
-      end
-
-      it '1st has backorder, 2nd has some' do
-        5.times { build_inventory_unit }
-
-        package1 = pack do |package|
-          5.times { |i| package.add inventory_units[i], :backordered }
-        end
-        package2 = pack do |package|
-          2.times { |i| package.add inventory_units[i] }
-        end
-
-        packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
-        packages = prioritizer.prioritized_packages
-
-        expect(packages[0].quantity(:backordered)).to eq 3
-        expect(packages[1].quantity(:on_hand)).to eq 2
-      end
-
-      it '1st has backorder, 2nd has all' do
-        5.times { build_inventory_unit }
-
-        package1 = pack do |package|
-          3.times { |i| package.add inventory_units[i], :backordered }
-        end
-        package2 = pack do |package|
-          5.times { |i| package.add inventory_units[i] }
-        end
-
-        packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
-        packages = prioritizer.prioritized_packages
-        expect(packages[0]).to eq package2
-        expect(packages[1]).to be_nil
-        expect(packages[0].quantity(:backordered)).to eq 0
-        expect(packages[0].quantity(:on_hand)).to eq 5
-      end
-    end
-  end
-end

data/spec/models/spree/stock/quantifier_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'unlimited supply' do
-  it 'can_supply? any amount' do
-    expect(subject.can_supply?(1)).to eq true
-    expect(subject.can_supply?(101)).to eq true
-    expect(subject.can_supply?(100_001)).to eq true
-  end
-end
-
-module Spree
-  module Stock
-    describe Quantifier, :type => :model do
-
-      let(:target_stock_location) { nil }
-      let!(:stock_location) { create :stock_location_with_items  }
-      let!(:stock_item) { stock_location.stock_items.order(:id).first }
-
-      subject { described_class.new(stock_item.variant, target_stock_location) }
-
-      specify { expect(subject.stock_items).to eq([stock_item]) }
-
-      context 'with a single stock location/item' do
-        it 'total_on_hand should match stock_item' do
-          expect(subject.total_on_hand).to eq stock_item.count_on_hand
-        end
-
-        context 'when track_inventory_levels is false' do
-          before { configure_spree_preferences { |config| config.track_inventory_levels = false } }
-
-          specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when variant inventory tracking is off' do
-          before { stock_item.variant.track_inventory = false }
-
-          specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when stock item allows backordering' do
-          specify { expect(subject.backorderable?).to be true }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when stock item prevents backordering' do
-          before { stock_item.update_attributes(backorderable: false) }
-
-          specify { expect(subject.backorderable?).to be false }
-
-          it 'can_supply? only upto total_on_hand' do
-            expect(subject.can_supply?(1)).to be true
-            expect(subject.can_supply?(10)).to be true
-            expect(subject.can_supply?(11)).to be false
-          end
-        end
-
-      end
-
-      context 'with multiple stock locations/items' do
-        let!(:stock_location_2) { create :stock_location }
-        let!(:stock_location_3) { create :stock_location, active: false }
-
-        before do
-          stock_location_2.stock_items.where(variant_id: stock_item.variant).update_all(count_on_hand: 5, backorderable: false)
-          stock_location_3.stock_items.where(variant_id: stock_item.variant).update_all(count_on_hand: 5, backorderable: false)
-        end
-
-        it 'total_on_hand should total all active stock_items' do
-          expect(subject.total_on_hand).to eq(15)
-        end
-
-        context 'when any stock item allows backordering' do
-          specify { expect(subject.backorderable?).to be true }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when all stock items prevent backordering' do
-          before { stock_item.update_attributes(backorderable: false) }
-
-          specify { expect(subject.backorderable?).to be false }
-
-          it 'can_supply? upto total_on_hand' do
-            expect(subject.can_supply?(1)).to be true
-            expect(subject.can_supply?(15)).to be true
-            expect(subject.can_supply?(16)).to be false
-          end
-        end
-
-      end
-
-      context 'with a specific stock location' do
-        let!(:stock_location_2)     { create :stock_location }
-        let!(:stock_location_3)     { create :stock_location, active: false }
-        let(:target_stock_location) { stock_location_3 }
-
-        before do
-          Spree::StockItem.update_all(count_on_hand: 0, backorderable: false)
-          stock_location_3.stock_items.where(variant_id: stock_item.variant).update_all(count_on_hand: 5, backorderable: false)
-        end
-
-        it 'can_supply? only upto total_on_hand' do
-          expect(subject.can_supply?(5)).to eq true
-          expect(subject.can_supply?(6)).to eq false
-        end
-      end
-
-    end
-  end
-end

data/spec/models/spree/stock/splitter/backordered_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      describe Backordered, :type => :model do
-        let(:variant) { build(:variant) }
-
-        let(:packer) { build(:stock_packer) }
-
-        subject { Backordered.new(packer) }
-
-        it 'splits packages by status' do
-          package = Package.new(packer.stock_location)
-          4.times { package.add build(:inventory_unit, variant: variant) }
-          5.times { package.add build(:inventory_unit, variant: variant), :backordered }
-
-          packages = subject.split([package])
-          expect(packages.count).to eq 2
-          expect(packages.first.quantity).to eq 4
-          expect(packages.first.on_hand.count).to eq 4
-          expect(packages.first.backordered.count).to eq 0
-
-          expect(packages[1].contents.count).to eq 5
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/splitter/base_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      describe Base, :type => :model do
-        let(:packer) { build(:stock_packer) }
-
-        it 'continues to splitter chain' do
-          splitter1 = Base.new(packer)
-          splitter2 = Base.new(packer, splitter1)
-          packages = []
-
-          expect(splitter1).to receive(:split).with(packages)
-          splitter2.split(packages)
-        end
-
-      end
-    end
-  end
-end

data/spec/models/spree/stock/splitter/shipping_category_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      describe ShippingCategory, :type => :model do
-
-        let(:order) { create(:order_with_line_items, line_items_count: 1) }
-        let(:line_item) { order.line_items.first }
-        let(:variant1) { build(:variant) }
-        let(:variant2) { build(:variant) }
-        let(:shipping_category_1) { create(:shipping_category, name: 'A') }
-        let(:shipping_category_2) { create(:shipping_category, name: 'B') }
-
-        def inventory_unit1
-          build(:inventory_unit, variant: variant1, order: order, line_item: line_item).tap do |inventory_unit|
-            inventory_unit.variant.product.shipping_category = shipping_category_1
-          end
-        end
-
-        def inventory_unit2
-          build(:inventory_unit, variant: variant2, order: order, line_item: line_item).tap do |inventory_unit|
-            inventory_unit.variant.product.shipping_category = shipping_category_2
-          end
-        end
-
-        let(:packer) { build(:stock_packer) }
-
-        subject { ShippingCategory.new(packer) }
-
-        it 'splits each package by shipping category' do
-          package1 = Package.new(packer.stock_location)
-          4.times { package1.add inventory_unit1 }
-          8.times { package1.add inventory_unit2 }
-
-          package2 = Package.new(packer.stock_location)
-          6.times { package2.add inventory_unit1 }
-          9.times { package2.add inventory_unit2, :backordered }
-
-          packages = subject.split([package1, package2])
-          expect(packages[0].quantity).to eq 4
-          expect(packages[1].quantity).to eq 8
-          expect(packages[2].quantity).to eq 6
-          expect(packages[3].quantity).to eq 9
-        end
-
-      end
-    end
-  end
-end

data/spec/models/spree/stock/splitter/weight_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      describe Weight, :type => :model do
-        let(:packer) { build(:stock_packer) }
-        let(:variant) { build(:base_variant, :weight => 100) }
-
-        subject { Weight.new(packer) }
-
-        it 'splits and keeps splitting until all packages are underweight' do
-          package = Package.new(packer.stock_location)
-          4.times { package.add build(:inventory_unit, variant: variant) }
-          packages = subject.split([package])
-          expect(packages.size).to eq 4
-        end
-
-        it 'handles packages that can not be reduced' do
-          package = Package.new(packer.stock_location)
-          allow(variant).to receive_messages(:weight => 200)
-          2.times { package.add build(:inventory_unit, variant: variant) }
-          packages = subject.split([package])
-          expect(packages.size).to eq 2
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock_item_spec.rb

@@ -1,426 +0,0 @@
-require 'spec_helper'
-
-describe Spree::StockItem, :type => :model do
-  let(:stock_location) { create(:stock_location_with_items) }
-
-  subject { stock_location.stock_items.order(:id).first }
-
-  it 'maintains the count on hand for a variant' do
-    expect(subject.count_on_hand).to eq 10
-  end
-
-  it "can return the stock item's variant's name" do
-    expect(subject.variant_name).to eq(subject.variant.name)
-  end
-
-  context "available to be included in shipment" do
-    context "has stock" do
-      it { expect(subject).to be_available }
-    end
-
-    context "backorderable" do
-      before { subject.backorderable = true }
-      it { expect(subject).to be_available }
-    end
-
-    context "no stock and not backorderable" do
-      before do
-        subject.backorderable = false
-        allow(subject).to receive_messages(count_on_hand: 0)
-      end
-
-      it { expect(subject).not_to be_available }
-    end
-  end
-
-  describe 'reduce_count_on_hand_to_zero' do
-    context 'when count_on_hand > 0' do
-      before(:each) do
-        subject.update_column('count_on_hand', 4)
-         subject.reduce_count_on_hand_to_zero
-       end
-
-       it { expect(subject.count_on_hand).to eq(0) }
-     end
-
-     context 'when count_on_hand > 0' do
-       before(:each) do
-         subject.update_column('count_on_hand', -4)
-         @count_on_hand = subject.count_on_hand
-         subject.reduce_count_on_hand_to_zero
-       end
-
-       it { expect(subject.count_on_hand).to eq(@count_on_hand) }
-     end
-  end
-
-  context "adjust count_on_hand" do
-    let!(:current_on_hand) { subject.count_on_hand }
-
-    it 'is updated pessimistically' do
-      copy = Spree::StockItem.find(subject.id)
-
-      subject.adjust_count_on_hand(5)
-      expect(subject.count_on_hand).to eq(current_on_hand + 5)
-
-      expect(copy.count_on_hand).to eq(current_on_hand)
-      copy.adjust_count_on_hand(5)
-      expect(copy.count_on_hand).to eq(current_on_hand + 10)
-    end
-
-    context "item out of stock (by two items)" do
-      let(:inventory_unit) { double('InventoryUnit') }
-      let(:inventory_unit_2) { double('InventoryUnit2') }
-
-      before do
-        allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2])
-        subject.update_column(:count_on_hand, -2)
-      end
-
-      # Regression test for #3755
-      it "processes existing backorders, even with negative stock" do
-        expect(inventory_unit).to receive(:fill_backorder)
-        expect(inventory_unit_2).not_to receive(:fill_backorder)
-        subject.adjust_count_on_hand(1)
-        expect(subject.count_on_hand).to eq(-1)
-      end
-
-      # Test for #3755
-      it "does not process backorders when stock is adjusted negatively" do
-        expect(inventory_unit).not_to receive(:fill_backorder)
-        expect(inventory_unit_2).not_to receive(:fill_backorder)
-        subject.adjust_count_on_hand(-1)
-        expect(subject.count_on_hand).to eq(-3)
-      end
-
-      context "adds new items" do
-        before { allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2]) }
-
-        it "fills existing backorders" do
-          expect(inventory_unit).to receive(:fill_backorder)
-          expect(inventory_unit_2).to receive(:fill_backorder)
-
-          subject.adjust_count_on_hand(3)
-          expect(subject.count_on_hand).to eq(1)
-        end
-      end
-    end
-  end
-
-  context "set count_on_hand" do
-    let!(:current_on_hand) { subject.count_on_hand }
-
-    it 'is updated pessimistically' do
-      copy = Spree::StockItem.find(subject.id)
-
-      subject.set_count_on_hand(5)
-      expect(subject.count_on_hand).to eq(5)
-
-      expect(copy.count_on_hand).to eq(current_on_hand)
-      copy.set_count_on_hand(10)
-      expect(copy.count_on_hand).to eq(current_on_hand)
-    end
-
-    context "item out of stock (by two items)" do
-      let(:inventory_unit) { double('InventoryUnit') }
-      let(:inventory_unit_2) { double('InventoryUnit2') }
-
-      before { subject.set_count_on_hand(-2) }
-
-      it "doesn't process backorders" do
-        expect(subject).not_to receive(:backordered_inventory_units)
-      end
-
-      context "adds new items" do
-        before { allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2]) }
-
-        it "fills existing backorders" do
-          expect(inventory_unit).to receive(:fill_backorder)
-          expect(inventory_unit_2).to receive(:fill_backorder)
-
-          subject.set_count_on_hand(1)
-          expect(subject.count_on_hand).to eq(1)
-        end
-      end
-    end
-  end
-
-  context "with stock movements" do
-    before { Spree::StockMovement.create(stock_item: subject, quantity: 1) }
-
-    it "doesnt raise ReadOnlyRecord error" do
-      expect { subject.destroy }.not_to raise_error
-    end
-  end
-
-  context "destroyed" do
-    before { subject.destroy }
-
-    it "recreates stock item just fine" do
-      expect {
-        stock_location.stock_items.create!(variant: subject.variant)
-      }.not_to raise_error
-    end
-
-    it "doesnt allow recreating more than one stock item at once" do
-      stock_location.stock_items.create!(variant: subject.variant)
-
-      expect {
-        stock_location.stock_items.create!(variant: subject.variant)
-      }.to raise_error ActiveRecord::RecordInvalid
-    end
-  end
-
-  describe "#after_save" do
-    before do
-      subject.variant.update_column(:updated_at, 1.day.ago)
-    end
-
-    before do
-      Spree::Config.binary_inventory_cache = binary_inventory_cache
-    end
-
-    context "binary_inventory_cache is set to false (default)" do
-      let(:binary_inventory_cache) { false }
-
-      context "in_stock? changes" do
-        it "touches its variant" do
-          expect do
-            subject.set_count_on_hand(0)
-          end.to change { subject.variant.updated_at }
-        end
-      end
-
-      context "in_stock? does not change" do
-        it "touches its variant" do
-          expect do
-            subject.set_count_on_hand(-1)
-          end.to change { subject.variant.updated_at }
-        end
-      end
-    end
-
-    context "binary_inventory_cache is set to true" do
-      let(:binary_inventory_cache) { true }
-
-      context "in_stock? changes" do
-        it "touches its variant" do
-          expect do
-            subject.set_count_on_hand(0)
-          end.to change { subject.variant.updated_at }
-        end
-
-        # Regression spec
-        context "stock changes to below zero" do
-          it "touches its variant" do
-            expect do
-              subject.set_count_on_hand(-1)
-            end.to change { subject.variant.updated_at }
-          end
-        end
-      end
-
-      context "in_stock? does not change" do
-        it "does not touch its variant" do
-          expect do
-            subject.set_count_on_hand(1)
-          end.not_to change { subject.reload.variant.updated_at }
-        end
-      end
-
-      context "when a new stock location is added" do
-        it "touches its variant" do
-          expect do
-            create(:stock_location)
-          end.to change { subject.variant.reload.updated_at }
-        end
-      end
-    end
-  end
-
-  describe "#after_touch" do
-    it "touches its variant" do
-      expect do
-        subject.touch
-      end.to change { subject.variant.updated_at }
-    end
-  end
-
-  # Regression test for #4651
-  context "variant" do
-    it "can be found even if the variant is deleted" do
-      subject.variant.destroy
-      expect(subject.reload.variant).not_to be_nil
-    end
-  end
-
-  describe 'validations' do
-    describe 'count_on_hand' do
-      shared_examples_for 'valid count_on_hand' do
-        before(:each) do
-          subject.save
-        end
-
-        it 'has :no errors_on' do
-          expect(subject.errors_on(:count_on_hand).size).to eq(0)
-        end
-      end
-
-      shared_examples_for 'not valid count_on_hand' do
-        before(:each) do
-          subject.save
-        end
-
-        it 'has 1 error_on' do
-          expect(subject.error_on(:count_on_hand).size).to eq(1)
-        end
-        it { expect(subject.errors[:count_on_hand]).to include 'must be greater than or equal to 0' }
-      end
-
-      context 'when count_on_hand not changed' do
-        context 'when not backorderable' do
-          before(:each) do
-            subject.backorderable = false
-          end
-          it_should_behave_like 'valid count_on_hand'
-        end
-
-        context 'when backorderable' do
-          before(:each) do
-            subject.backorderable = true
-          end
-          it_should_behave_like 'valid count_on_hand'
-        end
-      end
-
-      context 'when count_on_hand changed' do
-        context 'when backorderable' do
-          before(:each) do
-            subject.backorderable = true
-          end
-          context 'when both count_on_hand and count_on_hand_was are positive' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand + 3)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-
-            context 'when count_on_hand is smaller than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand - 2)
-              end
-
-              it_should_behave_like 'valid count_on_hand'
-            end
-          end
-
-          context 'when both count_on_hand and count_on_hand_was are negative' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, -3)
-                subject.send(:count_on_hand=, subject.count_on_hand + 2)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-
-            context 'when count_on_hand is smaller than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand - 3)
-              end
-
-              it_should_behave_like 'valid count_on_hand'
-            end
-          end
-
-          context 'when both count_on_hand is positive and count_on_hand_was is negative' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, -3)
-                subject.send(:count_on_hand=, subject.count_on_hand + 6)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-          end
-
-          context 'when both count_on_hand is negative and count_on_hand_was is positive' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand - 6)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-          end
-        end
-
-        context 'when not backorderable' do
-          before(:each) do
-            subject.backorderable = false
-          end
-
-          context 'when both count_on_hand and count_on_hand_was are positive' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand + 3)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-
-            context 'when count_on_hand is smaller than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand - 2)
-              end
-
-              it_should_behave_like 'valid count_on_hand'
-            end
-          end
-
-          context 'when both count_on_hand and count_on_hand_was are negative' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, -3)
-                subject.send(:count_on_hand=, subject.count_on_hand + 2)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-
-            context 'when count_on_hand is smaller than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, -3)
-                subject.send(:count_on_hand=, subject.count_on_hand - 3)
-              end
-
-              it_should_behave_like 'not valid count_on_hand'
-            end
-          end
-
-          context 'when both count_on_hand is positive and count_on_hand_was is negative' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, -3)
-                subject.send(:count_on_hand=, subject.count_on_hand + 6)
-              end
-              it_should_behave_like 'valid count_on_hand'
-            end
-          end
-
-          context 'when both count_on_hand is negative and count_on_hand_was is positive' do
-            context 'when count_on_hand is greater than count_on_hand_was' do
-              before(:each) do
-                subject.update_column(:count_on_hand, 3)
-                subject.send(:count_on_hand=, subject.count_on_hand - 6)
-              end
-              it_should_behave_like 'not valid count_on_hand'
-            end
-          end
-        end
-      end
-    end
-  end
-end