solidus_active_shipping 1.0.0

data/spec/integrations/calculators/ups_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe 'UPS calculators', :vcr do
+  include_context 'UPS setup'
+  include_context 'package setup'
+
+  subject { described_class.new.compute_package(package) }
+
+  context 'with Canadian origin address' do
+    include_context 'Canada stock location'
+
+    describe Spree::Calculator::Shipping::Ups::Express do
+      it { is_expected.to eq(139.1) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::WorldwideExpedited  do
+      it { is_expected.to eq(97.15) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::Saver do
+      it { is_expected.to eq(132.25) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::Standard do
+      it { is_expected.to eq(35.34) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::ThreeDaySelect do
+      it { is_expected.to eq(89.7) }
+    end
+  end
+
+  context 'with US origin address' do
+    include_context 'US stock location'
+
+    describe Spree::Calculator::Shipping::Ups::Ground do
+      it { is_expected.to eq(14.2) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::NextDayAir do
+      it { is_expected.to eq(79.47) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::NextDayAirEarlyAm do
+      it { is_expected.to eq(110.29) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::NextDayAirSaver do
+      it { is_expected.to eq(77.46) }
+    end
+
+    describe Spree::Calculator::Shipping::Ups::SecondDayAir do
+      it { is_expected.to eq(27.97) }
+    end
+  end
+end

data/spec/lib/spree/active_shipping/bogus_carrier.rb

@@ -0,0 +1,18 @@
+module Spree
+  module ActiveShipping
+    # Bogus carrier useful for testing.  For some reasons the plugin version of this class does not work
+    # properly (it fails to return a RateResponse)
+    class BogusCarrier < ::ActiveShipping::Carrier
+      include RSpec::Mocks::ExampleMethods
+
+      def name
+        "BogusCarrier"
+      end
+
+      # We're stubbing the rates because actual RateEstimate are too elaborate
+      def find_rates(origin, destination, packages, options = {})
+        ::ActiveShipping::RateResponse.new(true, "success!", {}, :rates => [instance_double('rate', service_name: 'Bogus Calculator', price: 999)], :xml => "")
+      end
+    end
+  end
+end

data/spec/lib/spree/calculator/shipping/bogus_calculator.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Spree
+  module Calculator::Shipping
+    module ActiveShipping
+      class BogusCalculator < Spree::Calculator::Shipping::ActiveShipping::Base
+        def carrier
+          @carrier ||= Spree::ActiveShipping::BogusCarrier.new
+        end
+
+        def self.description
+          "Bogus Calculator"
+        end
+      end
+    end
+  end
+end

data/spec/models/active_shipping_calculator_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Spree::Calculator::Shipping do
+  # NOTE: All specs will use the bogus calculator
+  # (no login information needed)
+
+  let(:address) { FactoryGirl.create(:address) }
+  let(:variant_1) { FactoryGirl.create(:variant, weight: 1) }
+  let(:variant_2) { FactoryGirl.create(:variant, weight: 2) }
+  let!(:order) do
+    FactoryGirl.create(:order_with_line_items, ship_address: address, line_items_count: 2,
+                                               line_items_attributes: [{ quantity: 2, variant: variant_1 }, { quantity: 2, variant: variant_2 }])
+  end
+
+  let(:calculator) { Spree::Calculator::Shipping::ActiveShipping::BogusCalculator.new }
+  let(:package) { order.shipments.first.to_package }
+
+  before(:each) do
+    order.create_proposed_shipments
+    Spree::ActiveShipping::Config.set(units: 'imperial')
+    Spree::ActiveShipping::Config.set(unit_multiplier: 1)
+    Spree::ActiveShipping::Config.set(handling_fee: 0)
+  end
+
+  describe 'available' do
+    context 'when rates are available' do
+      it 'should return true' do
+        expect(calculator.available?(package)).to eq true
+      end
+
+      it 'should use zero as a valid weight for service' do
+        allow(calculator.carrier).to receive(:max_weight_for_country).and_return(0)
+        expect(calculator.available?(package)).to eq true
+      end
+    end
+
+    context 'when rates are not available' do
+      let(:invalid_response) do
+        ::ActiveShipping::RateResponse.new(true, 'success!', {}, rates: [], xml: '')
+      end
+
+      before do
+        allow(calculator.carrier).to receive(:find_rates).and_return(invalid_response)
+      end
+
+      it 'should return false' do
+        expect(calculator.available?(package)).to eq false
+      end
+    end
+
+    context 'when there is an error retrieving the rates' do
+      before do
+        allow(calculator.carrier).to receive(:find_rates).and_raise(::ActiveShipping::ResponseError)
+      end
+
+      it 'should return false' do
+        expect(calculator.available?(package)).to eq false
+      end
+    end
+  end
+
+  describe 'available?' do
+    # regression test for #164 and #171
+    it 'should not return rates if the weight requirements for the destination country are not met' do
+      # if max_weight_for_country is nil -> the carrier does not ship to that country
+      # if max_weight_for_country is 0 -> the carrier does not have weight restrictions to that country
+      allow(calculator).to receive(:max_weight_for_country).and_return(nil)
+      expect(calculator).to receive(:is_package_shippable?).and_raise(Spree::ShippingError)
+      expect(calculator.available?(package)).to eq false
+    end
+  end
+
+  describe 'compute' do
+    subject { calculator.compute(package) }
+
+    context 'when the cache is warm' do
+      it 'should check the cache first before finding rates' do
+        # Since the cache is cleared between the tests, cache.fetch will return a miss,
+        # but by passing a block { Hash.new }, the return value of the block will be
+        # written under the given cache key so we simulate a warm cache
+        Rails.cache.fetch(calculator.send(:cache_key, package)) { Hash.new }
+        expect(calculator.carrier).not_to receive(:find_rates)
+        subject
+      end
+    end
+
+    context 'when the cache is empty' do
+      before do
+        # We're stubbing the carrier method because we
+        # need to check that a specific instance of carrier
+        # is receiving or not the function call (otherwise test will
+        # pass but only because carrier we're watching and the carrier
+        # used by the calculator are different)
+        allow(calculator.carrier).to receive(:find_rates).and_call_original
+      end
+
+      it 'should call .find_rates' do
+        expect(calculator.carrier).to receive(:find_rates)
+        subject
+      end
+    end
+
+    context 'with valid response' do
+      it "should return rate based on calculator's service_name" do
+        expect(subject).to eq 9.99
+      end
+
+      it 'should include handling_fee when configured' do
+        Spree::ActiveShipping::Config.set(handling_fee: 100)
+        expect(subject).to eq 10.99
+      end
+
+      it 'should return nil if service_name is not found in rate_hash' do
+        allow(calculator.class).to receive(:description) { 'invalid service_name' }
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'with invalid response' do
+      before do
+        allow(calculator.carrier).to receive(:find_rates).and_raise(::ActiveShipping::ResponseError)
+      end
+
+      it 'should raise a Spree::ShippingError' do
+        expect { subject }.to raise_exception(Spree::ShippingError)
+      end
+    end
+  end
+
+  describe 'service_name' do
+    it 'should return description when not defined' do
+      expect(calculator.class.service_name).to eq calculator.description
+    end
+  end
+
+  # We make an exception and tests this the private method because max_weight values
+  # are difficult to tests conclusively through the
+  describe 'get_max_weight' do
+    include_context 'US stock location'
+    include_context 'package setup'
+
+    context 'when the max_weight from the calculator is non-zero and max_weight_per_package is zero' do
+      before do
+        allow(calculator).to receive(:max_weight_for_country).and_return(1)
+        allow(calculator).to receive(:max_weight_per_package).and_return(0)
+      end
+
+      it 'uses the max_weight_for_country as a max_weight' do
+        expect(calculator.send(:get_max_weight, package)).to eq calculator.send(:max_weight_for_country)
+      end
+    end
+
+    context 'when the max_weight from the calculator is zero and max_weight_per_package is non-zero' do
+      before do
+        allow(calculator).to receive(:max_weight_for_country).and_return(0)
+        allow(calculator).to receive(:max_weight_per_package).and_return(1)
+      end
+
+      it 'uses the max_weight_per_package as a max_weight' do
+        expect(calculator.send(:get_max_weight, package)).to eq calculator.send(:max_weight_per_package)
+      end
+    end
+
+    context 'when the max_weight from the calculator is non-zero and max_weight_per_package is non-zero' do
+      before do
+        allow(calculator).to receive(:max_weight_per_package).and_return(SecureRandom.random_number(19) + 1)
+        allow(calculator).to receive(:max_weight_for_country).and_return(SecureRandom.random_number(19) + 1)
+      end
+
+      it 'uses the lesser one of the two values' do
+        min = [calculator.send(:max_weight_for_country), calculator.send(:max_weight_per_package)].min
+        expect(calculator.send(:get_max_weight, package)).to eq min
+      end
+    end
+
+    context 'when the max_weight is zero and max_weight_per_package is zero' do
+      it 'uses 0 as a max_eight' do
+        expect(calculator.send(:get_max_weight, package)).to be_zero
+      end
+    end
+  end
+end

data/spec/models/carriers/usps_calculator_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Spree::Calculator::Shipping::Usps do
+  let(:address) { FactoryGirl.create(:address) }
+  let(:variant_1) { FactoryGirl.create(:variant, weight: 1) }
+  let(:variant_2) { FactoryGirl.create(:variant, weight: 2) }
+  let!(:order) do
+    FactoryGirl.create(:order_with_line_items, ship_address: address, line_items_count: 2,
+                       line_items_attributes: [{ quantity: 2, variant: variant_1}, { quantity: 2, variant: variant_2 }] )
+  end
+
+  let(:carrier) { ActiveShipping::USPS.new(login: 'FAKEFAKEFAKE') }
+  let(:calculator) { Spree::Calculator::Shipping::Usps::ExpressMail.new }
+  let(:package) { order.shipments.first.to_package }
+
+  before(:each) do
+    order.create_proposed_shipments
+    Spree::ActiveShipping::Config.set(units: 'imperial')
+    Spree::ActiveShipping::Config.set(unit_multiplier: 1)
+    Spree::ActiveShipping::Config.set(handling_fee: 0)
+
+    stub_request(:get, %r{http:\/\/production.shippingapis.com\/ShippingAPI.dll.*})
+        .to_return(body: fixture(:normal_rates_request))
+
+    # Since the response can be cached, we explicitly clear cache
+    # so each test can be run from a clean slate
+    Rails.cache.delete(calculator.send(:cache_key, package))
+  end
+
+  describe 'compute' do
+    subject { calculator.compute(package) }
+
+    it 'should use the carrier supplied in the initializer' do
+      expect(subject).to eq 14.1
+    end
+
+    context 'with valid response' do
+      it "should return rate based on calculator's service_code" do
+        allow(calculator.class).to receive(:service_code) { 'dom:3' }
+        expect(subject).to eq 14.1
+      end
+
+      it 'should include handling_fee when configured' do
+        Spree::ActiveShipping::Config.set(handling_fee: 100)
+        allow(calculator.class).to receive(:service_code) { 'dom:3' }
+        expect(subject).to eq 15.1
+      end
+
+      it 'should return nil if service_code is not found in rate_hash' do
+        allow(calculator.class).to receive(:service_code) { 'invalid service_code' }
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'with invalid response' do
+      before do
+        allow(calculator).to receive(:carrier).and_return(carrier)
+        allow(carrier).to receive(:find_rates).and_raise(::ActiveShipping::ResponseError)
+      end
+
+      it 'should raise a Spree::ShippingError' do
+        expect{ subject }.to raise_exception(Spree::ShippingError)
+      end
+    end
+  end
+
+  describe 'service_name' do
+    it 'should return description when not defined' do
+      expect(calculator.class.service_name).to eq calculator.description
+    end
+  end
+end

data/spec/models/package_builder_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Spree::PackageBuilder do
+  include_context 'Canada stock location'
+  include PackageHelper
+
+  let(:shipping_calculator) do
+    Spree::Calculator::Shipping::ActiveShipping::BogusCalculator.new
+  end
+
+  let(:package_builder) { Spree::PackageBuilder.new }
+
+  before do
+    # We disable the multiplier so it's simpler to test
+    allow(package_builder).to receive(:multiplier).and_return(1)
+  end
+
+  describe 'process' do
+    include_context 'package setup'
+
+    let(:max_weight) { 0 }
+
+    subject { package_builder.process(package, max_weight) }
+
+    it 'returns an array of ActiveShipping::Package' do
+      expect(subject.map(&:class).uniq).to match_array([ActiveShipping::Package])
+    end
+
+    it 'uses the unit multiplier in the calculations' do
+      allow(package_builder).to receive(:multiplier).and_return(2)
+      expect(subject.sum(&:weight)).to eq (package.weight * 2)
+    end
+
+    context 'when one product has a zero weight' do
+      let(:variant_1) { FactoryGirl.create(:variant, weight: 0) }
+
+      it 'ignores products with nil weight' do
+        expect(subject.sum(&:weight)).to eq (variant_2.weight * 2)
+      end
+    end
+
+    context 'when one product has a nil weight' do
+      let(:variant_1) { FactoryGirl.create(:variant, weight: nil) }
+      let(:variant_2) { FactoryGirl.create(:variant, weight: nil) }
+      let(:default_weight) { Spree::ActiveShipping::Config[:default_weight] }
+
+      it 'use the default_weight as a weight value' do
+        expect(subject.sum(&:weight)).to eq( default_weight * 4 )
+      end
+    end
+
+    context 'with an order containing only products with associated product_packages' do
+      let(:product_weight) { 20 }
+      let(:product_package1) { FactoryGirl.create(:product_package, weight: product_weight) }
+      let(:product_package2) { FactoryGirl.create(:product_package, weight: product_weight) }
+      let(:product_with_packages) do
+        build(
+          :variant,
+          weight: product_weight,
+          product: build(
+            :product,
+            product_packages: [product_package1, product_package2]
+        )
+        )
+      end
+
+      let(:package) do
+        build(:stock_package,
+              stock_location: stock_location,
+              contents: [build_content_items(product_with_packages, 2, order),
+                         build_content_items(product_with_packages, 1, order)].flatten)
+      end
+
+      context 'when there is non-zero max_weight' do
+        context 'when the product_package weight exceeds the allowed max_weight' do
+          let(:max_weight) { product_weight - 1 }
+
+          it 'raise a Spree::Shipping error' do
+            expect { subject }.to raise_error(Spree::ShippingError)
+          end
+        end
+
+        context 'when the product_packages weight does not exceed the allowed max_weight' do
+          let(:max_weight) { 1000 }
+
+          it 'return a ActiveShipping::Package for each ProductPackage of each ContentItem' do
+            # Each individual item in the Order as a 1-1 association with a ContentItem
+            expected_size = package.contents.sum { |item| item.variant.product.product_packages.size }
+            expect(subject.size).to eq expected_size
+          end
+        end
+      end
+
+      context 'when there is no max weight (0)' do
+        it 'return a ActiveShipping::Package for each ProductPackage of each ContentItem' do
+          # Each individual item in the Order as a 1-1 association with a ContentItem
+          expected_size = package.contents.sum { |item| item.variant.product.product_packages.size }
+          expect(subject.size).to eq expected_size
+        end
+      end
+    end
+
+    context 'with an order containing only products without any associated product_packages' do
+      include_context 'package setup'
+
+      context 'when there is non-zero max_weight' do
+        context 'and their combined weight is lower than the max_weight' do
+          let(:max_weight) { package.weight + 1 }
+
+          it 'will combine items into the same package' do
+            expect(subject.size).to eq 1
+          end
+        end
+
+        context 'and their combined weight is higher than the max_weight' do
+          let(:max_weight) { package.weight - 1 }
+
+          it 'will split items into multiple packages' do
+            expect(subject.size).to eq 2
+          end
+        end
+
+        context 'and the weight of a single item is higher than the max_weight' do
+          let(:max_weight) { variant_2.weight - 1 }
+          it 'will raise an Spree::ShippingError' do
+            expect { subject }.to raise_error(Spree::ShippingError)
+          end
+        end
+      end
+
+      context 'when there is no max_weight' do
+        it 'will combine all items into the same package' do
+          expect(subject.size).to eq 1
+        end
+      end
+    end
+
+    context 'with an order containing some products with product_packages and some products without' do
+      let(:product_weight) { 20 }
+      let(:product_package1) { FactoryGirl.create(:product_package, weight: product_weight) }
+      let(:product_package2) { FactoryGirl.create(:product_package, weight: product_weight) }
+
+      let(:product_no_packages) { FactoryGirl.create(:variant, weight: 5) }
+      let(:product_with_packages) do
+        build(
+          :variant,
+          weight: product_weight,
+          product: build(
+            :product,
+            product_packages: [product_package1, product_package2]
+        )
+        )
+      end
+
+      let(:package) do
+        build(:stock_package,
+              stock_location: stock_location,
+              contents: [build_content_items(product_with_packages, 1, order),
+                         build_content_items(product_no_packages, 1, order),
+                         build_content_items(product_no_packages, 1, order)].flatten)
+      end
+
+      let(:max_weight) { 1000 }
+
+      it 'products with product_packages will not be combined with product with no packages' do
+        active_shipping_packages = subject
+        # First package in the array is the "default package" who should
+        # only include product_with_no_packages x2
+        expect(active_shipping_packages[0].weight).to eq (product_no_packages.weight * 2)
+      end
+    end
+  end
+end