solidus_core 1.0.7 → 1.1.0.beta1

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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Differentiator, :type => :model do
-      let(:variant1) { mock_model(Variant) }
-      let(:variant2) { mock_model(Variant) }
-
-      let(:line_item1) { build(:line_item, variant: variant1, quantity: 2) }
-      let(:line_item2) { build(:line_item, variant: variant2, quantity: 2) }
-
-      let(:stock_location) { mock_model(StockLocation) }
-
-      let(:inventory_unit1) { build(:inventory_unit, variant: variant1, line_item: line_item1) }
-      let(:inventory_unit2) { build(:inventory_unit, variant: variant2, line_item: line_item2) }
-
-      let(:order) { mock_model(Order, line_items: [line_item1, line_item2]) }
-
-      let(:package1) do
-        Package.new(stock_location).tap { |p| p.add(inventory_unit1) }
-      end
-
-      let(:package2) do
-        Package.new(stock_location).tap { |p| p.add(inventory_unit2) }
-      end
-
-      let(:packages) { [package1, package2] }
-
-      subject { Differentiator.new(order, packages) }
-
-      it { is_expected.to be_missing }
-
-      it 'calculates the missing items' do
-        expect(subject.missing[variant1]).to eq 1
-        expect(subject.missing[variant2]).to eq 1
-      end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Estimator, :type => :model do
-      let!(:shipping_method) { create(:shipping_method) }
-      let(:package) { build(:stock_package, contents: inventory_units.map { |i| ContentItem.new(inventory_unit) }) }
-      let(:order) { build(:order_with_line_items) }
-      let(:inventory_units) { order.inventory_units }
-
-      subject { Estimator.new(order) }
-
-      context "#shipping rates" do
-        before(:each) do
-          shipping_method.zones.first.members.create(:zoneable => order.ship_address.country)
-          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :available?).and_return(true)
-          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :compute).and_return(4.00)
-          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :preferences).and_return({:currency => currency})
-          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :marked_for_destruction?)
-
-          allow(package).to receive_messages(:shipping_methods => [shipping_method])
-        end
-
-        let(:currency) { "USD" }
-
-        shared_examples_for "shipping rate matches" do
-          it "returns shipping rates" do
-            shipping_rates = subject.shipping_rates(package)
-            expect(shipping_rates.first.cost).to eq 4.00
-          end
-        end
-
-        shared_examples_for "shipping rate doesn't match" do
-          it "does not return shipping rates" do
-            shipping_rates = subject.shipping_rates(package)
-            expect(shipping_rates).to eq([])
-          end
-        end
-
-        context "when the order's ship address is in the same zone" do
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "when the order's ship address is in a different zone" do
-          before { shipping_method.zones.each{|z| z.members.delete_all} }
-          it_should_behave_like "shipping rate doesn't match"
-        end
-
-        context "when the calculator is not available for that order" do
-          before { allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :available?).and_return(false) }
-          it_should_behave_like "shipping rate doesn't match"
-        end
-
-        context "when the currency is nil" do
-          let(:currency) { nil }
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "when the currency is an empty string" do
-          let(:currency) { "" }
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "when the current matches the order's currency" do
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "if the currency is different than the order's currency" do
-          let(:currency) { "GBP" }
-          it_should_behave_like "shipping rate doesn't match"
-        end
-
-        it "sorts shipping rates by cost" do
-          shipping_methods = 3.times.map { create(:shipping_method) }
-          allow(shipping_methods[0]).to receive_message_chain(:calculator, :compute).and_return(5.00)
-          allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(3.00)
-          allow(shipping_methods[2]).to receive_message_chain(:calculator, :compute).and_return(4.00)
-
-          allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
-
-          expect(subject.shipping_rates(package).map(&:cost)).to eq %w[3.00 4.00 5.00].map(&BigDecimal.method(:new))
-        end
-
-        context "general shipping methods" do
-          let(:shipping_methods) { 2.times.map { create(:shipping_method) } }
-
-          it "selects the most affordable shipping rate" do
-            allow(shipping_methods[0]).to receive_message_chain(:calculator, :compute).and_return(5.00)
-            allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(3.00)
-
-            allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
-
-            expect(subject.shipping_rates(package).sort_by(&:cost).map(&:selected)).to eq [true, false]
-          end
-
-          it "selects the most affordable shipping rate and doesn't raise exception over nil cost" do
-            allow(shipping_methods[0]).to receive_message_chain(:calculator, :compute).and_return(1.00)
-            allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(nil)
-
-            allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
-
-            subject.shipping_rates(package)
-          end
-        end
-
-        context "involves backend only shipping methods" do
-          let(:backend_method) { create(:shipping_method, display_on: "back_end") }
-          let(:generic_method) { create(:shipping_method) }
-
-          before do
-            allow(backend_method).to receive_message_chain(:calculator, :compute).and_return(0.00)
-            allow(generic_method).to receive_message_chain(:calculator, :compute).and_return(5.00)
-            allow(subject).to receive(:shipping_methods).and_return([backend_method, generic_method])
-          end
-
-          it "does not return backend rates at all" do
-            expect(subject.shipping_rates(package).map(&:shipping_method_id)).to eq([generic_method.id])
-          end
-
-          # regression for #3287
-          it "doesn't select backend rates even if they're more affordable" do
-            expect(subject.shipping_rates(package).map(&:selected)).to eq [true]
-          end
-        end
-
-        context "includes tax adjustments if applicable" do
-          let!(:tax_rate) { create(:tax_rate, zone: order.tax_zone) }
-
-          before do
-            Spree::ShippingMethod.all.each do |sm|
-              sm.tax_category_id = tax_rate.tax_category_id
-              sm.save
-            end
-            package.shipping_methods.map(&:reload)
-          end
-
-
-          it "links the shipping rate and the tax rate" do
-            shipping_rates = subject.shipping_rates(package)
-            expect(shipping_rates.first.tax_rate).to eq(tax_rate)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe InventoryUnitBuilder, :type => :model do
-      let(:line_item_1) { build(:line_item) }
-      let(:line_item_2) { build(:line_item, quantity: 2) }
-      let(:order) { build(:order, line_items: [line_item_1, line_item_2]) }
-
-      subject { InventoryUnitBuilder.new(order) }
-
-      describe "#units" do
-        it "returns an inventory unit for each quantity for the order's line items" do
-          units = subject.units
-          expect(units.count).to eq 3
-          expect(units.first.line_item).to eq line_item_1
-          expect(units.first.variant).to eq line_item_1.variant
-
-          expect(units[1].line_item).to eq line_item_2
-          expect(units[1].variant).to eq line_item_2.variant
-
-          expect(units[2].line_item).to eq line_item_2
-          expect(units[2].variant).to eq line_item_2.variant
-        end
-
-        it "builds the inventory units as pending" do
-          expect(subject.units.map(&:pending).uniq).to eq [true]
-        end
-
-        it "associates the inventory units to the order" do
-          expect(subject.units.map(&:order).uniq).to eq [order]
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Package, :type => :model do
-      let(:variant) { build(:variant, weight: 25.0) }
-      let(:stock_location) { build(:stock_location) }
-      let(:order) { build(:order) }
-
-      subject { Package.new(stock_location) }
-
-      def build_inventory_unit
-        build(:inventory_unit, variant: variant)
-      end
-
-      it 'calculates the weight of all the contents' do
-        4.times { subject.add build_inventory_unit }
-        expect(subject.weight).to eq(100.0)
-      end
-
-      it 'filters by on_hand and backordered' do
-        4.times { subject.add build_inventory_unit }
-        3.times { subject.add build_inventory_unit, :backordered }
-        expect(subject.on_hand.count).to eq 4
-        expect(subject.backordered.count).to eq 3
-      end
-
-      it 'calculates the quantity by state' do
-        4.times { subject.add build_inventory_unit }
-        3.times { subject.add build_inventory_unit, :backordered }
-
-        expect(subject.quantity).to eq 7
-        expect(subject.quantity(:on_hand)).to eq 4
-        expect(subject.quantity(:backordered)).to eq 3
-      end
-
-      it 'returns nil for content item not found' do
-        unit = build_inventory_unit
-        item = subject.find_item(unit, :on_hand)
-        expect(item).to be_nil
-      end
-
-      it 'finds content item for an inventory unit' do
-        unit = build_inventory_unit
-        subject.add unit
-        item = subject.find_item(unit, :on_hand)
-        expect(item.quantity).to eq 1
-      end
-
-      # Contains regression test for #2804
-      it 'builds a list of shipping methods common to all categories' do
-        category1 = create(:shipping_category)
-        category2 = create(:shipping_category)
-        method1   = create(:shipping_method)
-        method2   = create(:shipping_method)
-        method1.shipping_categories = [category1, category2]
-        method2.shipping_categories = [category1]
-        variant1 = mock_model(Variant, shipping_category: category1)
-        variant2 = mock_model(Variant, shipping_category: category2)
-        variant3 = mock_model(Variant, shipping_category: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant2)),
-                    ContentItem.new(build(:inventory_unit, variant: variant3))]
-
-        package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to eq([method1])
-      end
-
-      it 'builds an empty list of shipping methods when no categories' do
-        variant  = mock_model(Variant, shipping_category: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant))]
-        package  = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to be_empty
-      end
-
-      it "can convert to a shipment" do
-        2.times { subject.add build_inventory_unit }
-        subject.add build_inventory_unit, :backordered
-
-        shipping_method = build(:shipping_method)
-        subject.shipping_rates = [ Spree::ShippingRate.new(shipping_method: shipping_method, cost: 10.00, selected: true) ]
-
-        shipment = subject.to_shipment
-        expect(shipment.stock_location).to eq subject.stock_location
-        expect(shipment.inventory_units.size).to eq 3
-
-        first_unit = shipment.inventory_units.first
-        expect(first_unit.variant).to eq variant
-        expect(first_unit.state).to eq 'on_hand'
-        expect(first_unit).to be_pending
-
-        last_unit = shipment.inventory_units.last
-        expect(last_unit.variant).to eq variant
-        expect(last_unit.state).to eq 'backordered'
-
-        expect(shipment.shipping_method).to eq shipping_method
-      end
-
-      it 'does not add an inventory unit to a package twice' do
-        # since inventory units currently don't have a quantity
-        unit = build_inventory_unit
-        subject.add unit
-        subject.add unit
-        expect(subject.quantity).to eq 1
-        expect(subject.contents.first.inventory_unit).to eq unit
-        expect(subject.contents.first.quantity).to eq 1
-      end
-
-      describe "#add_multiple" do
-        it "adds multiple inventory units" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit] }.to change { subject.quantity }.by(2)
-        end
-
-        it "allows adding with a state" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit], :backordered }.to change { subject.backordered.count }.by(2)
-        end
-
-        it "defaults to adding with the on hand state" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit] }.to change { subject.on_hand.count }.by(2)
-        end
-      end
-
-      describe "#remove" do
-        let(:unit) { build_inventory_unit }
-        context "there is a content item for the inventory unit" do
-
-          before { subject.add unit }
-
-          it "removes that content item" do
-            expect { subject.remove(unit) }.to change { subject.quantity }.by(-1)
-            expect(subject.contents.map(&:inventory_unit)).not_to include unit
-          end
-        end
-
-        context "there is no content item for the inventory unit" do
-          it "doesn't change the set of content items" do
-            expect { subject.remove(unit) }.not_to change { subject.quantity }
-          end
-        end
-      end
-
-      describe "#order" do
-        let(:unit) { build_inventory_unit }
-        context "there is an inventory unit" do
-
-          before { subject.add unit }
-
-          it "returns an order" do
-            expect(subject.order).to be_a_kind_of Spree::Order
-            expect(subject.order).to eq unit.order
-          end
-        end
-
-        context "there is no inventory unit" do
-          it "returns nil" do
-            expect(subject.order).to eq nil
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Packer, :type => :model do
-      let!(:inventory_units) { 5.times.map { build(:inventory_unit) } }
-      let(:stock_location) { create(:stock_location) }
-
-      subject { Packer.new(stock_location, inventory_units) }
-
-      context 'packages' do
-        it 'builds an array of packages' do
-          packages = subject.packages
-          expect(packages.size).to eq 1
-          expect(packages.first.contents.size).to eq 5
-        end
-
-        it 'allows users to set splitters to an empty array' do
-          packages = Packer.new(stock_location, inventory_units, []).packages
-          expect(packages.size).to eq 1
-        end
-      end
-
-      context 'default_package' do
-        it 'contains all the items' do
-          package = subject.default_package
-          expect(package.contents.size).to eq 5
-        end
-
-        it 'variants are added as backordered without enough on_hand' do
-          expect(stock_location).to receive(:fill_status).exactly(5).times.and_return(
-            *(Array.new(3, [1,0]) + Array.new(2, [0,1]))
-          )
-
-          package = subject.default_package
-          expect(package.on_hand.size).to eq 3
-          expect(package.backordered.size).to eq 2
-        end
-
-        context "location doesn't have order items in stock" do
-          let(:stock_location) { create(:stock_location, propagate_all_variants: false) }
-          let(:packer) { Packer.new(stock_location, inventory_units) }
-
-          it "builds an empty package" do
-            expect(packer.default_package.contents).to be_empty
-          end
-        end
-
-        context "not enough on hand and not backorderable" do
-          let(:packer) { Packer.new(stock_location, inventory_units) }
-
-          before do
-            stock_location.stock_items.update_all(backorderable: false)
-            stock_location.stock_items.each { |si| si.set_count_on_hand(0) }
-          end
-
-          it "raises an error" do
-            expect { packer.default_package }.to raise_error Spree::Order::InsufficientStock
-          end
-        end
-
-        context "doesn't track inventory levels" do
-          let(:variant) { build(:variant) }
-          let(:order) { build(:order_with_line_items, line_items_count: 1) }
-          let(:line_item) { order.line_items.first }
-          let(:inventory_units) {
-            30.times.map do
-              build(
-                :inventory_unit,
-                order: order,
-                line_item: line_item,
-                variant: variant,
-              )
-            end
-          }
-
-          before { Config.track_inventory_levels = false }
-
-          it "doesn't bother stock items status in stock location" do
-            expect(subject.stock_location).not_to receive(:fill_status)
-            subject.default_package
-          end
-
-          it "still creates package with proper quantity" do
-            expect(subject.default_package.quantity).to eql 30
-          end
-        end
-      end
-    end
-  end
-end