solidus_core 2.10.2 → 2.11.0

data/spec/models/spree/shipping_calculator_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe ShippingCalculator, type: :model do
-    let(:line_item1) { build(:line_item, price: 10) }
-    let(:line_item2) { build(:line_item, price: 20) }
-
-    let(:inventory_unit1) { build(:inventory_unit, line_item: line_item1) }
-    let(:inventory_unit2) { build(:inventory_unit, line_item: line_item2) }
-
-    let(:package) do
-      build(
-        :stock_package,
-        contents: [
-          Spree::Stock::ContentItem.new(inventory_unit1),
-          Spree::Stock::ContentItem.new(inventory_unit1),
-          Spree::Stock::ContentItem.new(inventory_unit2)
-        ]
-      )
-    end
-
-    subject { described_class.new }
-
-    it 'computes with a package' do
-      expect(subject).to receive(:compute_package).with(package)
-      subject.compute(package)
-    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_manifest_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.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) }
-    subject(:manifest) { described_class.new(inventory_units: inventory_units) }
-
-    def build_unit(variant, attrs = {})
-      attrs = { variant: variant, shipment: shipment }.merge(attrs)
-      attrs[:line_item] = order.contents.add(variant)
-      InventoryUnit.new(attrs)
-    end
-
-    describe "#items" do
-      context 'empty' do
-        let(:inventory_units) { [] }
-        it "has correct item" do
-          expect(manifest.items.count).to eq 0
-        end
-      end
-
-      context 'single unit' do
-        let(:inventory_units) { [build_unit(variant)] }
-        it "has correct item" do
-          expect(manifest.items.count).to eq 1
-          expect(manifest.items[0]).to have_attributes(
-            variant: variant,
-            quantity: 1,
-            states: { "on_hand" => 1 }
-          )
-        end
-      end
-
-      context 'two units of same variant' do
-        let(:inventory_units) { [build_unit(variant), build_unit(variant)] }
-        it "has correct item" do
-          expect(manifest.items.count).to eq 1
-          expect(manifest.items[0]).to have_attributes(
-            variant: variant,
-            quantity: 2,
-            states: { "on_hand" => 2 }
-          )
-        end
-      end
-
-      context 'two units of different variants' do
-        let(:variant2){ create :variant }
-        let(:inventory_units) { [build_unit(variant), build_unit(variant2)] }
-        it "has correct item" do
-          expect(manifest.items.count).to eq 2
-          expect(manifest.items[0]).to have_attributes(
-            variant: variant,
-            quantity: 1,
-            states: { "on_hand" => 1 }
-          )
-          expect(manifest.items[1]).to have_attributes(
-            variant: variant2,
-            quantity: 1,
-            states: { "on_hand" => 1 }
-          )
-        end
-      end
-    end
-
-    describe "#for_order" do
-      let!(:order2) { create(:order_with_line_items) }
-      context 'single unit' do
-        let(:inventory_units) { [inventory_unit] }
-        let(:inventory_unit) { build_unit(variant) }
-
-        before do
-          allow(inventory_unit).to receive(:order_id) { order.id }
-        end
-
-        it "has single ManifestItem in correct order" do
-          expect(manifest.for_order(order).items.count).to eq 1
-        end
-
-        it "has no ManifestItem in other order" do
-          expect(manifest.for_order(order2).items.count).to eq 0
-        end
-      end
-
-      context 'one units in each order' do
-        let(:order_2) { build_stubbed(:order) }
-        let(:inventory_units) { [inventory_unit_one, inventory_unit_two] }
-        let(:inventory_unit_one) { build_unit(variant) }
-        let(:inventory_unit_two) { build_unit(variant) }
-
-        before do
-          allow(inventory_unit_one).to receive(:order_id) { order.id }
-          allow(inventory_unit_two).to receive(:order_id) { order_2.id }
-        end
-
-        it "has single ManifestItem in first order" do
-          expect(manifest.for_order(order).items.count).to eq 1
-        end
-
-        it "has single ManifestItem in second order" do
-          expect(manifest.for_order(order_2).items.count).to eq 1
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/shipping_method_spec.rb

@@ -1,292 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class DummyShippingCalculator < Spree::ShippingCalculator
-end
-
-RSpec.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
-    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.errors[:name].size).to eq(1)
-    end
-
-    context "shipping category" do
-      it "validates presence of at least one" do
-        expect(subject.errors[:base].size).to eq(1)
-      end
-
-      context "one associated" do
-        before do
-          subject.shipping_categories.push create(:shipping_category)
-          subject.valid?
-        end
-
-        it { expect(subject.errors[:base].size).to eq(0) }
-      end
-    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 https://github.com/spree/spree/issues/4320
-  context "soft deletion" do
-    let(:shipping_method) { create(:shipping_method) }
-    it "soft-deletes when destroy is called" do
-      shipping_method.discard
-      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
-
-  describe "display_on=" do
-    subject do
-      Spree::Deprecation.silence do
-        described_class.new(display_on: display_on).available_to_users
-      end
-    end
-
-    context "with 'back_end'" do
-      let(:display_on) { 'back_end' }
-      it { should be false }
-    end
-
-    context "with 'both'" do
-      let(:display_on) { 'both' }
-      it { should be true }
-    end
-
-    context "with 'front_end'" do
-      let(:display_on) { 'front_end' }
-      it { should be true }
-    end
-  end
-
-  describe "display_on" do
-    subject do
-      Spree::Deprecation.silence do
-        described_class.new(available_to_users: available_to_users).display_on
-      end
-    end
-
-    context "when available_to_users is true" do
-      let(:available_to_users) { true }
-      it { should == 'both' }
-    end
-
-    context "when available_to_users is false" do
-      let(:available_to_users) { false }
-      it { should == 'back_end' }
-    end
-  end
-
-  describe '.available_to_store' do
-    let(:store) { create(:store) }
-    let(:first_shipping_method) { create(:shipping_method, stores: [store]) }
-    let(:second_shipping_method) { create(:shipping_method, stores: [store]) }
-
-    subject { [first_shipping_method, second_shipping_method] }
-
-    it 'raises an exception if no store is passed as argument' do
-      expect {
-        described_class.available_to_store(nil)
-      }.to raise_exception(ArgumentError, 'You must provide a store')
-    end
-
-    context 'when the store has no shipping methods associated' do
-      before { store.shipping_methods = [] }
-
-      it 'returns all shipping methods' do
-        expect(store.shipping_methods).to eq([])
-        expect(described_class.available_to_store(store)).to eq(subject)
-      end
-    end
-
-    context 'when the store has shipping methods associated' do
-      before { create(:shipping_method) }
-
-      it 'returns the associated records' do
-        expect(store.shipping_methods).to eq(subject)
-        expect(described_class.available_to_store(store)).to eq(subject)
-      end
-    end
-  end
-end

data/spec/models/spree/shipping_rate_spec.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ShippingRate, type: :model do
-  let(:address) { create(:address) }
-  let(:foreign_address) { create :address, country_iso_code: "DE" }
-  let(:order) { create :order, ship_address: address }
-  let(:shipment) { create(:shipment, order: order) }
-  let(:shipping_method) { create(:shipping_method, tax_category: tax_category) }
-  let(:tax_category) { create :tax_category }
-
-  subject(:shipping_rate) do
-    Spree::ShippingRate.new(
-      shipment: shipment,
-      shipping_method: shipping_method,
-      cost: 10
-    )
-  end
-
-  context "#display_price" do
-    let!(:default_zone) { create :zone, countries: [address.country] }
-    let!(:other_zone) { create :zone, countries: [foreign_address.country] }
-
-    before do
-      allow(order).to receive(:tax_address).and_return(order_address)
-    end
-
-    context 'with one included tax rate' do
-      let!(:tax_rate) do
-        create :tax_rate,
-        included_in_price: true,
-        name: "VAT",
-        zone: default_zone,
-        tax_categories: [tax_category]
-      end
-
-      let(:order_address) { address }
-
-      before do
-        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
-      end
-
-      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 'with one additional tax rate' do
-      let!(:tax_rate) do
-        create :tax_rate,
-        included_in_price: false,
-        name: "Sales Tax",
-        zone: default_zone,
-        tax_categories: [tax_category]
-      end
-
-      let(:order_address) { address }
-
-      before do
-        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
-      end
-
-      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 'with two additional tax rates' do
-      let!(:tax_rate) do
-        create :tax_rate,
-        included_in_price: false,
-        name: "Sales Tax",
-        zone: default_zone,
-        tax_categories: [tax_category]
-      end
-
-      let!(:other_tax_rate) do
-        create :tax_rate,
-        included_in_price: false,
-        name: "Other Sales Tax",
-        zone: default_zone,
-        tax_categories: [tax_category],
-        amount: 0.05
-      end
-
-      let(:order_address) { address }
-
-      before do
-        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
-      end
-
-      it "shows correct tax amount" do
-        expect(shipping_rate.display_price.to_s).to match(/\$10.00 \(.*, .*\)/)
-        expect(shipping_rate.display_price.to_s).to include("+ $1.00 Sales Tax")
-        expect(shipping_rate.display_price.to_s).to include("+ $0.50 Other Sales Tax")
-      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
-
-  # Regression test for https://github.com/spree/spree/issues/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.current)
-      shipping_rate.save
-      shipping_rate.reload
-      expect(shipping_rate.shipping_method).to eq(shipping_method)
-    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