solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/shipment_spec.rb

@@ -14,24 +14,16 @@ describe Spree::Shipment, type: :model do
       shipping_rates: [
         Spree::ShippingRate.new(
           shipping_method: shipping_method,
-          selected: true,
-        ),
+          selected: true
+        )
       ],
-      stock_location: stock_location,
+      stock_location: stock_location
     )
   end
 
   let(:variant) { mock_model(Spree::Variant) }
   let(:line_item) { mock_model(Spree::LineItem, variant: variant) }
 
-  describe "precision of pre_tax_amount" do
-    let!(:line_item) { create :line_item, pre_tax_amount: 4.2051 }
-
-    it "keeps four digits of precision even when reloading" do
-      expect(line_item.reload.pre_tax_amount).to eq(4.2051)
-    end
-  end
-
   # Regression test for https://github.com/spree/spree/issues/4063
   context "number generation" do
     before { allow(order).to receive :update! }
@@ -47,7 +39,7 @@ describe Spree::Shipment, type: :model do
   it 'is backordered if one if its inventory_units is backordered' do
     shipment.inventory_units = [
       build(:inventory_unit, state: 'backordered', shipment: nil),
-      build(:inventory_unit, state: 'shipped', shipment: nil),
+      build(:inventory_unit, state: 'shipped', shipment: nil)
     ]
     expect(shipment).to be_backordered
   end
@@ -64,7 +56,7 @@ describe Spree::Shipment, type: :model do
     end
 
     it 'returns pending if backordered' do
-      allow(shipment).to receive_messages inventory_units: [mock_model(Spree::InventoryUnit, backordered?: true)]
+      allow(shipment).to receive_messages inventory_units: [mock_model(Spree::InventoryUnit, allow_ship?: false, canceled?: false)]
       expect(shipment.determine_state(order)).to eq 'pending'
     end
 
@@ -165,10 +157,12 @@ describe Spree::Shipment, type: :model do
     let(:shipment) { create(:shipment) }
     let(:shipping_method1) { create(:shipping_method) }
     let(:shipping_method2) { create(:shipping_method) }
-    let(:shipping_rates) { [
+    let(:shipping_rates) {
+      [
       Spree::ShippingRate.new(shipping_method: shipping_method1, cost: 10.00, selected: true),
       Spree::ShippingRate.new(shipping_method: shipping_method2, cost: 20.00)
-    ] }
+    ]
+    }
 
     it 'returns shipping_method from selected shipping_rate' do
       shipment.shipping_rates.delete_all
@@ -181,7 +175,7 @@ describe Spree::Shipment, type: :model do
       before { allow(shipment).to receive(:can_get_rates?){ true } }
 
       it 'should request new rates, and maintain shipping_method selection' do
-        expect(Spree::Stock::Estimator).to receive(:new).with(shipment.order).and_return(mock_estimator)
+        expect(Spree::Stock::Estimator).to receive(:new).with(no_args).and_return(mock_estimator)
         allow(shipment).to receive_messages(shipping_method: shipping_method2)
 
         expect(shipment.refresh_rates).to eq(shipping_rates)
@@ -189,7 +183,7 @@ describe Spree::Shipment, type: :model do
       end
 
       it 'should handle no shipping_method selection' do
-        expect(Spree::Stock::Estimator).to receive(:new).with(shipment.order).and_return(mock_estimator)
+        expect(Spree::Stock::Estimator).to receive(:new).with(no_args).and_return(mock_estimator)
         allow(shipment).to receive_messages(shipping_method: nil)
         expect(shipment.refresh_rates).to eq(shipping_rates)
         expect(shipment.reload.selected_shipping_rate).not_to be_nil
@@ -203,7 +197,7 @@ describe Spree::Shipment, type: :model do
       end
 
       it "can't get rates without a shipping address" do
-        shipment.order(ship_address: nil)
+        shipment.order.update_attributes!(ship_address: nil)
         expect(shipment.refresh_rates).to eq([])
       end
 
@@ -228,22 +222,31 @@ describe Spree::Shipment, type: :model do
           expect(package.on_hand.count).to eq 1
           expect(package.backordered.count).to eq 1
         end
+
+        it 'should set the shipment to itself' do
+          expect(shipment.to_package.shipment).to eq(shipment)
+        end
       end
     end
   end
 
   context "#update!" do
     shared_examples_for "immutable once shipped" do
+      before { shipment.update_columns(state: 'shipped') }
+
       it "should remain in shipped state once shipped" do
-        shipment.state = 'shipped'
-        expect(shipment).to receive(:update_columns).with(state: 'shipped', updated_at: kind_of(Time))
-        shipment.update!(order)
+        expect {
+          shipment.update!(order)
+        }.not_to change { shipment.state }
       end
     end
 
     shared_examples_for "pending if backordered" do
       it "should have a state of pending if backordered" do
-        allow(shipment).to receive_messages(inventory_units: [mock_model(Spree::InventoryUnit, backordered?: true)])
+        # Set as ready so we can test for change
+        shipment.update_attributes!(state: 'ready')
+
+        allow(shipment).to receive_messages(inventory_units: [mock_model(Spree::InventoryUnit, allow_ship?: false, canceled?: false)])
         expect(shipment).to receive(:update_columns).with(state: 'pending', updated_at: kind_of(Time))
         shipment.update!(order)
       end
@@ -252,6 +255,8 @@ describe Spree::Shipment, type: :model do
     context "when order cannot ship" do
       before { allow(order).to receive_messages can_ship?: false }
       it "should result in a 'pending' state" do
+        # Set as ready so we can test for change
+        shipment.update_attributes!(state: 'ready')
         expect(shipment).to receive(:update_columns).with(state: 'pending', updated_at: kind_of(Time))
         shipment.update!(order)
       end
@@ -269,14 +274,9 @@ describe Spree::Shipment, type: :model do
 
     context "when payment is not required" do
       before do
-        @original_require_payment = Spree::Config[:require_payment_to_ship]
         Spree::Config[:require_payment_to_ship] = false
       end
 
-      after do
-        Spree::Config[:require_payment_to_ship] = @original_require_payment
-      end
-
       it "should result in a 'ready' state" do
         expect(shipment).to receive(:update_columns).with(state: 'ready', updated_at: kind_of(Time))
         shipment.update!(order)
@@ -331,8 +331,6 @@ describe Spree::Shipment, type: :model do
   end
 
   context "when order is completed" do
-    after { Spree::Config.set track_inventory_levels: true }
-
     before do
       allow(order).to receive_messages completed?: true
       allow(order).to receive_messages canceled?: false
@@ -424,7 +422,7 @@ describe Spree::Shipment, type: :model do
     end
 
     context "when any inventory is backordered" do
-      before { allow_any_instance_of(Spree::InventoryUnit).to receive(:backordered?).and_return(true) }
+      before { allow_any_instance_of(Spree::InventoryUnit).to receive(:allow_ship?).and_return(false) }
       it "should result in a 'ready' state" do
         shipment.resume!
         expect(shipment.state).to eq 'pending'
@@ -435,7 +433,7 @@ describe Spree::Shipment, type: :model do
       before do
         allow(order).to receive_messages(can_ship?: true)
         allow(order).to receive_messages(paid?: true)
-        allow_any_instance_of(Spree::InventoryUnit).to receive(:backordered?).and_return(false)
+        allow_any_instance_of(Spree::InventoryUnit).to receive(:allow_ship?).and_return(true)
       end
 
       it "should result in a 'ready' state" do
@@ -538,9 +536,14 @@ describe Spree::Shipment, type: :model do
   end
 
   context "changes shipping rate via general update" do
+    let(:store) { create :store }
     let(:order) do
       Spree::Order.create(
-        payment_total: 100, payment_state: 'paid', total: 100, item_total: 100
+        payment_total: 100,
+        payment_state: 'paid',
+        total: 100,
+        item_total: 100,
+        store: store
       )
     end
 
@@ -603,17 +606,30 @@ describe Spree::Shipment, type: :model do
   end
 
   context "#tracking_url" do
-    subject do
-      shipment.tracking_url
+    subject { shipment.tracking_url }
+
+    context "when tracking has not yet been set" do
+      it { is_expected.to be nil }
     end
 
-    before do
-      shipping_method.update!(tracking_url: "https://example.com/:tracking")
-      shipment.tracking = '1Z12345'
+    context "when tracking has been set, but a shipping method is not present" do
+      before do
+        shipment.tracking = "12345"
+        shipment.shipping_rates.clear
+      end
+
+      it { is_expected.to be nil }
     end
 
-    it "uses shipping method to determine url" do
-      is_expected.to eq("https://example.com/1Z12345")
+    context "when tracking has been set and a shipping method exists" do
+      before do
+        shipment.tracking = "12345"
+        shipment.shipping_method.update(tracking_url: "https://example.com/:tracking")
+      end
+
+      it "builds the tracking url with the shipping method" do
+        expect(subject).to eql("https://example.com/12345")
+      end
     end
   end
 
@@ -631,7 +647,7 @@ describe Spree::Shipment, type: :model do
 
     it "associates variant and order" do
       expect(inventory_units).to receive(:create).with(params)
-      unit = shipment.set_up_inventory('on_hand', variant, order, line_item)
+      shipment.set_up_inventory('on_hand', variant, order, line_item)
     end
   end
 
@@ -648,7 +664,7 @@ describe Spree::Shipment, type: :model do
   context "state changes" do
     before do
       # Must be stubbed so transition can succeed
-      allow(order).to receive_messages :paid? => true
+      allow(order).to receive_messages paid?: true
     end
 
     it "are logged to the database" do
@@ -662,13 +678,13 @@ describe Spree::Shipment, type: :model do
   end
 
   context "don't require shipment" do
-    let(:stock_location) { create(:stock_location, fulfillable: false)}
+    let(:stock_location) { create(:stock_location, fulfillable: false) }
     let(:unshippable_shipment) do
       create(
         :shipment,
         address: create(:address),
         stock_location: stock_location,
-        inventory_units: [build(:inventory_unit)],
+        inventory_units: [build(:inventory_unit)]
       )
     end
 

data/spec/models/spree/shipping_calculator_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 module Spree
-  describe ShippingCalculator, :type => :model do
-    let(:variant1) { build(:variant, :price => 10) }
-    let(:variant2) { build(:variant, :price => 20) }
+  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 })

data/spec/models/spree/shipping_manifest_spec.rb

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
 module Spree
-  describe ShippingManifest, :type => :model do
+  describe ShippingManifest, type: :model do
+    let!(:store) { create :store }
     let(:order) { Order.create! }
     let(:variant) { create :variant }
     let!(:shipment) { create(:shipment, state: 'pending', order: order) }
     let(:manifest) { described_class.new(inventory_units: inventory_units) }
 
-    def build_unit(variant, attrs={})
-      attrs = {order: order, variant: variant, shipment: shipment}.merge(attrs)
+    def build_unit(variant, attrs = {})
+      attrs = { order: order, variant: variant, shipment: shipment }.merge(attrs)
       attrs[:line_item] = attrs[:order].contents.add(attrs[:variant])
       InventoryUnit.new(attrs)
     end
@@ -30,7 +31,7 @@ module Spree
           expect(manifest.items[0]).to have_attributes(
             variant: variant,
             quantity: 1,
-            states: {"on_hand" => 1}
+            states: { "on_hand" => 1 }
           )
         end
       end
@@ -42,7 +43,7 @@ module Spree
           expect(manifest.items[0]).to have_attributes(
             variant: variant,
             quantity: 2,
-            states: {"on_hand" => 2}
+            states: { "on_hand" => 2 }
           )
         end
       end
@@ -55,12 +56,12 @@ module Spree
           expect(manifest.items[0]).to have_attributes(
             variant: variant,
             quantity: 1,
-            states: {"on_hand" => 1}
+            states: { "on_hand" => 1 }
           )
           expect(manifest.items[1]).to have_attributes(
             variant: variant2,
             quantity: 1,
-            states: {"on_hand" => 1}
+            states: { "on_hand" => 1 }
           )
         end
       end

data/spec/models/spree/shipping_method_spec.rb

@@ -3,29 +3,13 @@ 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
-
+describe Spree::ShippingMethod, type: :model do
   # Regression test for https://github.com/spree/spree/issues/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.shipping_rates.create!(shipping_method: shipping_method)
       shipment
     end
 
@@ -53,12 +37,6 @@ describe Spree::ShippingMethod, :type => :model do
     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" }
@@ -85,4 +63,151 @@ describe Spree::ShippingMethod, :type => :model do
       expect(shipping_method.deleted_at).not_to be_blank
     end
   end
+
+  describe ".with_all_shipping_category_ids" do
+    let(:category1) { create(:shipping_category) }
+    let(:category2) { create(:shipping_category) }
+
+    def matching(categories)
+      described_class.with_all_shipping_category_ids(categories.map(&:id))
+    end
+
+    context "with one associated shipping category" do
+      let!(:shipping_method) { create(:shipping_method, shipping_categories: [category1]) }
+
+      it "should match the associated category" do
+        expect(matching([category1])).to eq [shipping_method]
+      end
+
+      it "should not match the other category" do
+        expect(matching([category2])).to be_empty
+      end
+
+      it "should not match both categories" do
+        expect(matching([category1, category2])).to be_empty
+      end
+
+      context "with additional joins" do
+        before do
+          shipping_method.zones << create(:zone)
+        end
+        it "should not match both categories" do
+          result =
+            described_class.
+            joins(:zones).
+            with_all_shipping_category_ids([category1.id, category2.id])
+          expect(result).to be_empty
+        end
+      end
+    end
+
+    context "with two associated shipping categories" do
+      let!(:shipping_method) { create(:shipping_method, shipping_categories: [category1, category2]) }
+
+      it "should match the associated category" do
+        expect(matching([category1])).to eq [shipping_method]
+      end
+
+      it "should match both categories" do
+        expect(matching([category1, category2])).to eq [shipping_method]
+      end
+    end
+
+    context "with several shipping methods" do
+      let!(:shipping_method1) { create(:shipping_method, shipping_categories: [category1]) }
+      let!(:shipping_method2) { create(:shipping_method, shipping_categories: [category1, category2]) }
+      let!(:shipping_method3) { create(:shipping_method, shipping_categories: [category2]) }
+
+      it "matches correctly" do
+        expect(matching([category1])).to match_array [shipping_method1, shipping_method2]
+      end
+    end
+  end
+
+  describe ".available_in_stock_location" do
+    let!(:stock_location) { create :stock_location }
+    let!(:other_stock_location) { create :stock_location }
+
+    subject { described_class.available_in_stock_location(stock_location) }
+
+    context "when available_to_all" do
+      let!(:shipping_method) { create(:shipping_method, available_to_all: true) }
+
+      it "returns the shipping_method" do
+        is_expected.to eq [shipping_method]
+      end
+    end
+
+    context "when in stock location" do
+      let!(:shipping_method) { create(:shipping_method, available_to_all: false, stock_locations: [stock_location]) }
+
+      it "returns the shipping_method" do
+        is_expected.to eq [shipping_method]
+      end
+    end
+
+    context "when available_to_all and in stock location" do
+      let!(:shipping_method) { create(:shipping_method, available_to_all: true, stock_locations: [stock_location]) }
+
+      it "returns the shipping_method" do
+        is_expected.to eq [shipping_method]
+      end
+    end
+
+    context "when in no stock locations" do
+      let!(:shipping_method) { create(:shipping_method, available_to_all: false) }
+
+      it "returns no results" do
+        is_expected.to be_empty
+      end
+    end
+
+    context "when in another stock location" do
+      let!(:shipping_method) { create(:shipping_method, available_to_all: false, stock_locations: [other_stock_location]) }
+
+      it "returns no results" do
+        is_expected.to be_empty
+      end
+    end
+
+    context "when available_to_all and in another stock location" do
+      let!(:shipping_method) { create(:shipping_method, available_to_all: true, stock_locations: [other_stock_location]) }
+
+      it "returns the shipping_method" do
+        is_expected.to eq [shipping_method]
+      end
+    end
+
+    context "when multiple shipping methods match" do
+      let!(:shipping_method1) { create(:shipping_method, available_to_all: true, stock_locations: [other_stock_location]) }
+      let!(:shipping_method2) { create(:shipping_method, available_to_all: false, stock_locations: [stock_location]) }
+      let!(:shipping_method3) { create(:shipping_method, available_to_all: false, stock_locations: [other_stock_location]) }
+
+      it "returns both matching shipping_methods" do
+        is_expected.to match_array([shipping_method1, shipping_method2])
+      end
+    end
+  end
+
+  describe ".available_for_address" do
+    let!(:included_country) { create(:country, iso: "US") }
+    let!(:excluded_country) { create(:country, iso: "CA") }
+    let!(:included_zone) { create(:zone, countries: [included_country]) }
+    let!(:excluded_zone) { create(:zone, countries: [excluded_country]) }
+    let!(:shipping_method) { create(:shipping_method, zones: [included_zone]) }
+
+    let(:matches) { described_class.available_for_address(address) }
+    subject { matches }
+
+    context "address included in zone" do
+      let!(:address) { create(:address, country_iso_code: 'US') }
+
+      it { is_expected.to include(shipping_method) }
+    end
+
+    context "address included other zone" do
+      let!(:address) { create(:address, country_iso_code: 'CA') }
+      it { is_expected.to_not include(shipping_method) }
+    end
+  end
 end