solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/shipping_calculator_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe ShippingCalculator, :type => :model do
-    let(:variant1) { build(:variant, :price => 10) }
-    let(:variant2) { build(:variant, :price => 20) }
-
-    let(:package) do
-      build(:stock_package, variants_contents: { variant1 => 2, variant2 => 1 })
-    end
-
-    subject { ShippingCalculator.new }
-
-    it 'computes with a shipment' do
-      shipment = mock_model(Spree::Shipment)
-      expect(subject).to receive(:compute_shipment).with(shipment)
-      subject.compute(shipment)
-    end
-
-    it 'computes with a package' do
-      expect(subject).to receive(:compute_package).with(package)
-      subject.compute(package)
-    end
-
-    it 'compute_shipment must be overridden' do
-      expect {
-        subject.compute_shipment(shipment)
-      }.to raise_error NameError
-    end
-
-    it 'compute_package must be overridden' do
-      expect {
-        subject.compute_package(package)
-      }.to raise_error NotImplementedError
-    end
-
-    it 'checks availability for a package' do
-      expect(subject.available?(package)).to be true
-    end
-
-    it 'calculates totals for content_items' do
-      expect(subject.send(:total, package.contents)).to eq 40.00
-    end
-  end
-end

data/spec/models/spree/shipping_method_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-class DummyShippingCalculator < Spree::ShippingCalculator
-end
-
-describe Spree::ShippingMethod, :type => :model do
-  let(:shipping_method){ create(:shipping_method) }
-
-  context 'calculators' do
-    it "Should reject calculators that don't inherit from Spree::ShippingCalculator" do
-      allow(Spree::ShippingMethod).to receive_message_chain(:spree_calculators, :shipping_methods).and_return([
-        Spree::Calculator::Shipping::FlatPercentItemTotal,
-        Spree::Calculator::Shipping::PriceSack,
-        Spree::Calculator::DefaultTax,
-        DummyShippingCalculator # included as regression test for https://github.com/spree/spree/issues/3109
-      ])
-
-      expect(Spree::ShippingMethod.calculators).to eq([Spree::Calculator::Shipping::FlatPercentItemTotal, Spree::Calculator::Shipping::PriceSack, DummyShippingCalculator ])
-      expect(Spree::ShippingMethod.calculators).not_to eq([Spree::Calculator::DefaultTax])
-    end
-  end
-
-  # Regression test for #4492
-  context "#shipments" do
-    let!(:shipping_method) { create(:shipping_method) }
-    let!(:shipment) do
-      shipment = create(:shipment)
-      shipment.shipping_rates.create!(:shipping_method => shipping_method)
-      shipment
-    end
-
-    it "can gather all the related shipments" do
-      expect(shipping_method.shipments).to include(shipment)
-    end
-  end
-
-  context "validations" do
-    before { subject.valid? }
-
-    it "validates presence of name" do
-      expect(subject.error_on(:name).size).to eq(1)
-    end
-
-    context "shipping category" do
-      it "validates presence of at least one" do
-        expect(subject.error_on(:base).size).to eq(1)
-      end
-
-      context "one associated" do
-        before { subject.shipping_categories.push create(:shipping_category) }
-        it { expect(subject.error_on(:base).size).to eq(0) }
-      end
-    end
-  end
-
-  context 'factory' do
-    it "should set calculable correctly" do
-      expect(shipping_method.calculator.calculable).to eq(shipping_method)
-    end
-  end
-
-  context "generating tracking URLs" do
-    context "shipping method has a tracking URL mask on file" do
-      let(:tracking_url) { "https://track-o-matic.com/:tracking" }
-      before { allow(subject).to receive(:tracking_url) { tracking_url } }
-
-      context 'tracking number has spaces' do
-        let(:tracking_numbers) { ["1234 5678 9012 3456", "a bcdef"] }
-        let(:expectations) { %w[https://track-o-matic.com/1234%205678%209012%203456 https://track-o-matic.com/a%20bcdef] }
-
-        it "should return a single URL with '%20' in lieu of spaces" do
-          tracking_numbers.each_with_index do |num, i|
-            expect(subject.build_tracking_url(num)).to eq(expectations[i])
-          end
-        end
-      end
-    end
-  end
-
-  # Regression test for #4320
-  context "soft deletion" do
-    let(:shipping_method) { create(:shipping_method) }
-    it "soft-deletes when destroy is called" do
-      shipping_method.destroy
-      expect(shipping_method.deleted_at).not_to be_blank
-    end
-  end
-end

data/spec/models/spree/shipping_rate_spec.rb

@@ -1,142 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Spree::ShippingRate, :type => :model do
-  let(:shipment) { create(:shipment) }
-  let(:shipping_method) { create(:shipping_method) }
-  let(:shipping_rate) { Spree::ShippingRate.new(:shipment => shipment,
-                                                :shipping_method => shipping_method,
-                                                :cost => 10) }
-
-  context "#display_price" do
-    context "when tax included in price" do
-      context "when the tax rate is from the default zone" do
-        before { shipment.order.update_attributes!(ship_address_id: nil) }
-        let!(:zone) { create(:zone, :default_tax => true) }
-        let(:tax_rate) do
-          create(:tax_rate,
-            :name => "VAT",
-            :amount => 0.1,
-            :included_in_price => true,
-            :zone => zone)
-        end
-
-        before { shipping_rate.tax_rate = tax_rate }
-
-        it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$10.00 (incl. $0.91 #{tax_rate.name})")
-        end
-
-        context "when cost is zero" do
-          before do
-            shipping_rate.cost = 0
-          end
-
-          it "shows no tax amount" do
-            expect(shipping_rate.display_price.to_s).to eq("$0.00")
-          end
-        end
-      end
-
-      context "when the tax rate is from a non-default zone" do
-        let!(:default_zone) { create(:zone, :default_tax => true) }
-        let!(:non_default_zone) { create(:zone, :default_tax => false) }
-        let(:tax_rate) do
-          create(:tax_rate,
-            :name => "VAT",
-            :amount => 0.1,
-            :included_in_price => true,
-            :zone => non_default_zone)
-        end
-        before { shipping_rate.tax_rate = tax_rate }
-
-        it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$10.00 (excl. $0.91 #{tax_rate.name})")
-        end
-
-        context "when cost is zero" do
-          before do
-            shipping_rate.cost = 0
-          end
-
-          it "shows no tax amount" do
-            expect(shipping_rate.display_price.to_s).to eq("$0.00")
-          end
-        end
-      end
-    end
-
-    context "when tax is additional to price" do
-      let(:tax_rate) { create(:tax_rate, :name => "Sales Tax", :amount => 0.1) }
-      before { shipping_rate.tax_rate = tax_rate }
-
-      it "shows correct tax amount" do
-        expect(shipping_rate.display_price.to_s).to eq("$10.00 (+ $1.00 #{tax_rate.name})")
-      end
-
-      context "when cost is zero" do
-        before do
-          shipping_rate.cost = 0
-        end
-
-        it "shows no tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$0.00")
-        end
-      end
-    end
-
-    context "when the currency is JPY" do
-      let(:shipping_rate) { shipping_rate = Spree::ShippingRate.new(:cost => 205)
-                            allow(shipping_rate).to receive_messages(:currency => "JPY")
-                            shipping_rate }
-
-      it "displays the price in yen" do
-        expect(shipping_rate.display_price.to_s).to eq("¥205")
-      end
-    end
-  end
-
-  # Regression test for #3829
-  context "#shipping_method" do
-    it "can be retrieved" do
-      expect(shipping_rate.shipping_method.reload).to eq(shipping_method)
-    end
-
-    it "can be retrieved even when deleted" do
-      shipping_method.update_column(:deleted_at, Time.now)
-      shipping_rate.save
-      shipping_rate.reload
-      expect(shipping_rate.shipping_method).to eq(shipping_method)
-    end
-  end
-
-  context "#tax_rate" do
-    let!(:tax_rate) { create(:tax_rate) }
-
-    before do
-      shipping_rate.tax_rate = tax_rate
-    end
-
-    it "can be retrieved" do
-      expect(shipping_rate.tax_rate.reload).to eq(tax_rate)
-    end
-
-    it "can be retrieved even when deleted" do
-      tax_rate.update_column(:deleted_at, Time.now)
-      shipping_rate.save
-      shipping_rate.reload
-      expect(shipping_rate.tax_rate).to eq(tax_rate)
-    end
-  end
-
-  context "#shipping_method_code" do
-    before do
-      shipping_method.code = "THE_CODE"
-    end
-
-    it 'should be shipping_method.code' do
-      expect(shipping_rate.shipping_method_code).to eq("THE_CODE")
-    end
-  end
-end

data/spec/models/spree/state_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Spree::State, :type => :model do
-  it "can find a state by name or abbr" do
-    state = create(:state, :name => "California", :abbr => "CA")
-    expect(Spree::State.find_all_by_name_or_abbr("California")).to include(state)
-    expect(Spree::State.find_all_by_name_or_abbr("CA")).to include(state)
-  end
-
-  it "can find all states group by country id" do
-    state = create(:state)
-    expect(Spree::State.states_group_by_country_id).to eq({ state.country_id.to_s => [[state.id, state.name]] })
-  end
-end

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

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe AvailabilityValidator do
-      let(:validator) { Spree::Stock::AvailabilityValidator.new }
-
-      subject { validator.validate(line_item) }
-
-      shared_examples_for "fails validation" do
-        it "returns false" do
-          expect(subject).to eq false
-        end
-
-        it "adds a validation error" do
-          subject
-          display_name = "#{line_item.variant.name}"
-          display_name +=  " (#{line_item.variant.options_text})" unless line_item.variant.options_text.blank?
-          expect(line_item.errors).to match_array ["Quantity selected of #{display_name.inspect} is not available."]
-        end
-      end
-
-      shared_examples_for "passes validation" do
-        it "returns true" do
-          expect(subject).to eq true
-        end
-
-        it "doesn't add a validation error" do
-          expect(line_item.errors).to be_empty
-        end
-      end
-
-      context "line_item is not part of a shipment" do
-        let(:line_item) { create(:line_item) }
-
-        context "has stock in all stock locations" do
-          before do
-            Spree::StockItem.where(variant_id: line_item.variant_id).update_all(count_on_hand: 10, backorderable: false)
-          end
-
-          include_examples "passes validation"
-        end
-
-        context "doesn't have stock in any stock location" do
-          before do
-            Spree::StockItem.where(variant_id: line_item.variant_id).update_all(count_on_hand: 0, backorderable: false)
-          end
-
-          include_examples "fails validation"
-        end
-      end
-
-      context "line_item is part of a shipment" do
-        let!(:order)            { create(:order_with_line_items) }
-
-        context "has stock in all stock locations" do
-          let(:line_item)         { order.line_items.first }
-
-          before do
-            variant_ids = order.line_items.map(&:variant_id)
-            Spree::StockItem.where(variant_id: variant_ids).update_all(count_on_hand: 10, backorderable: false)
-          end
-
-          include_examples "passes validation"
-        end
-
-        context "doesn't have stock in a particular stock location" do
-          let(:variant)           { create(:variant) }
-          let(:line_item)         { order.line_items.find_by(variant_id: variant.id) }
-          let!(:stock_location_1) { create(:stock_location, name: "Test Warehouse", active: false) }
-
-          before do
-            order.contents.add(variant, 1, stock_location_quantities: { stock_location_1.id => 1})
-            order.contents.advance
-            stock_location_1.stock_items.update_all(count_on_hand: 0, backorderable: false)
-          end
-
-          include_examples "fails validation"
-        end
-      end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Coordinator, :type => :model do
-      let!(:order) { create(:order_with_line_items, line_items_count: 2) }
-
-      subject { Coordinator.new(order) }
-
-      context "packages" do
-        it "builds, prioritizes and estimates" do
-          expect(subject).to receive(:build_location_configured_packages).ordered
-          expect(subject).to receive(:build_packages).ordered
-          expect(subject).to receive(:prioritize_packages).ordered
-          expect(subject).to receive(:estimate_packages).ordered
-          subject.packages
-        end
-      end
-
-      describe "#shipments" do
-        let(:packages) { [build(:stock_package_fulfilled), build(:stock_package_fulfilled)] }
-
-        before { allow(subject).to receive(:packages).and_return(packages) }
-
-        it "turns packages into shipments" do
-          shipments = subject.shipments
-          expect(shipments.count).to eq packages.count
-          shipments.each { |shipment| expect(shipment).to be_a Shipment }
-        end
-
-        it "puts the order's ship address on the shipments" do
-          shipments = subject.shipments
-          shipments.each { |shipment| expect(shipment.address).to eq order.ship_address }
-        end
-      end
-
-      context "build packages" do
-        it "builds a package for all active stock locations" do
-          subject.packages.count == StockLocation.count
-        end
-
-        context "missing stock items in active stock location" do
-          let!(:another_location) { create(:stock_location, propagate_all_variants: false) }
-
-          it "builds packages only for valid active stock locations" do
-            expect(subject.build_packages.count).to eq(StockLocation.count - 1)
-          end
-        end
-      end
-
-      # regression spec
-      context "when there is one unit that has stock in a stock location that a non-tracked unit has no stock item in" do
-        let!(:stock_location_1) { create(:stock_location, propagate_all_variants: false, active: true) }
-        let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
-
-        let!(:variant_1) do
-          create(:variant, track_inventory: true).tap do |variant|
-            variant.stock_items.destroy_all
-            stock_item = variant.stock_items.create!(stock_location: stock_location_1)
-            stock_item.set_count_on_hand(10)
-          end
-        end
-        let!(:variant_2) do
-          create(:variant, track_inventory: false).tap do |variant|
-            variant.stock_items.destroy_all
-            stock_item = variant.stock_items.create!(stock_location: stock_location_2)
-            stock_item.set_count_on_hand(0)
-          end
-        end
-
-        let!(:order) { create(:order, line_items: [create(:line_item, variant: variant_1), create(:line_item, variant: variant_2)]) }
-
-        it "splits the inventory units to stock locations that they have stock items for" do
-          packages = subject.packages
-
-          expect(subject.packages.size).to eq 2
-
-          location_1_package = packages.detect { |p| p.stock_location == stock_location_1 }
-          location_2_package = packages.detect { |p| p.stock_location == stock_location_2 }
-
-          expect(location_1_package).to be_present
-          expect(location_2_package).to be_present
-
-          expect(location_1_package.contents.map(&:inventory_unit).map(&:variant)).to eq [variant_1]
-          expect(location_2_package.contents.map(&:inventory_unit).map(&:variant)).to eq [variant_2]
-        end
-      end
-
-      context "build location configured packages" do
-        context "there are configured stock locations" do
-          let(:stock_location) { order.variants.first.stock_locations.first }
-          let!(:stock_location_2) { create(:stock_location) }
-
-          before do
-            line_item_1 = order.line_items.first
-            line_item_2 = order.line_items.last
-            order.order_stock_locations.create(stock_location_id: stock_location.id, quantity: line_item_1.quantity, variant_id: line_item_1.variant_id)
-            order.order_stock_locations.create(stock_location_id: stock_location_2.id, quantity: line_item_2.quantity, variant_id: line_item_2.variant_id)
-          end
-
-          it "builds a package for each associated stock location" do
-            packages = subject.build_location_configured_packages
-            expect(packages.count).to eq(2)
-            expect(packages.map(&:stock_location)).to eq([stock_location, stock_location_2])
-          end
-        end
-        context "there are no configured stock locations" do
-          it "doesn't build any packages" do
-            packages = subject.build_location_configured_packages
-            expect(packages.count).to eq(0)
-          end
-        end
-      end
-    end
-  end
-end