spree_core 3.3.0.rc1 → 3.3.0.rc2

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_category_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Spree::ShippingCategory, type: :model do
-
-  describe '#validations' do
-    it 'should have a valid factory' do
-      expect(FactoryGirl.build(:shipping_category)).to be_valid
-    end
-
-    it 'should require name' do
-      expect(FactoryGirl.build(:shipping_category, name: '')).not_to be_valid
-    end
-
-    it 'should validate uniqueness' do
-      FactoryGirl.create(:shipping_category, name: 'Test')
-      expect(FactoryGirl.build(:shipping_category, name: 'Test')).not_to be_valid
-    end
-  end
-end

data/spec/models/spree/shipping_method_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-class DummyShippingCalculator < Spree::ShippingCalculator
-end
-
-describe Spree::ShippingMethod, type: :model do
-  let(:shipping_method){ create(:shipping_method) }
-  let(:frontend_shipping_method) { create :shipping_method, display_on: 'front_end' }
-  let(:backend_shipping_method) { create :shipping_method, display_on: 'back_end' }
-  let(:front_and_back_end_shipping_method) { create :shipping_method, display_on: 'both' }
-
-  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
-      context "is required" do
-        it { expect(subject.error_on(:base).size).to eq(1) }
-        it 'adds error to base' do
-          expect(subject.error_on(:base)).to include(I18n.t(:required_shipping_category,
-                                                            scope: [
-                                                              :activerecord, :errors, :models,
-                                                              'spree/shipping_method', :attributes, :base
-                                                            ]))
-        end
-      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
-
-  describe '#available_to_display?' do
-    context 'when available on frontend' do
-      it { expect(frontend_shipping_method.available_to_display?(Spree::ShippingMethod::DISPLAY_ON_FRONT_END)).to be true }
-      it { expect(backend_shipping_method.available_to_display?(Spree::ShippingMethod::DISPLAY_ON_FRONT_END)).to be false }
-      it { expect(front_and_back_end_shipping_method.available_to_display?(Spree::ShippingMethod::DISPLAY_ON_FRONT_END)).to be true }
-    end
-
-    context 'when available on backend' do
-      it { expect(frontend_shipping_method.available_to_display?(Spree::ShippingMethod::DISPLAY_ON_BACK_END)).to be false }
-      it { expect(backend_shipping_method.available_to_display?(Spree::ShippingMethod::DISPLAY_ON_BACK_END)).to be true }
-      it { expect(front_and_back_end_shipping_method.available_to_display?(Spree::ShippingMethod::DISPLAY_ON_BACK_END)).to be true }
-    end
-  end
-
-  describe '#frontend?' do
-    it { expect(frontend_shipping_method.send(:frontend?)).to be true }
-    it { expect(backend_shipping_method.send(:frontend?)).to be false }
-    it { expect(front_and_back_end_shipping_method.send(:frontend?)).to be true }
-  end
-
-  describe '#backend?' do
-    it { expect(frontend_shipping_method.send(:backend?)).to be false }
-    it { expect(backend_shipping_method.send(:backend?)).to be true }
-    it { expect(front_and_back_end_shipping_method.send(:backend?)).to be true }
-  end
-
-end

data/spec/models/spree/shipping_rate_spec.rb

@@ -1,140 +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) do
-    Spree::ShippingRate.new shipment: shipment,
-                            shipping_method: shipping_method,
-                            cost: 10
-  end
-
-  context "#display_price" do
-    context "when tax included in price" do
-      let!(:default_zone) { create(:zone, default_tax: true) }
-      let(:default_tax_rate) do
-        create :tax_rate,
-               name: "VAT",
-               amount: 0.1,
-               included_in_price: true,
-               zone: default_zone
-      end
-      context "when the tax rate is from the default zone" do
-
-        before { shipping_rate.tax_rate = default_tax_rate }
-
-        it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).
-            to eq("$10.00 (incl. $0.91 #{default_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 another zone" do
-        let!(:non_default_zone) { create(:zone, default_tax: false) }
-
-        let(:non_default_tax_rate) do
-          create :tax_rate,
-                 name: "VAT",
-                 amount: 0.2,
-                 included_in_price: true,
-                 zone: non_default_zone
-        end
-        before { shipping_rate.tax_rate = non_default_tax_rate }
-
-        it "deducts the other zone's VAT from the calculated shipping rate" do
-          expect(shipping_rate.display_price.to_s).
-            to eq("$10.00 (incl. $1.67 #{non_default_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) { Spree::ShippingRate.new(cost: 205) }
-
-      before { allow(shipping_rate).to receive_messages(currency: "JPY") }
-
-      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.current)
-      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.current)
-      shipping_rate.save
-      shipping_rate.reload
-      expect(shipping_rate.tax_rate).to eq(tax_rate)
-    end
-  end
-
-  describe 'delegate' do
-    it { is_expected.to delegate_method(:code).to(:shipping_method).with_prefix(true) }
-  end
-end

data/spec/models/spree/state_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Spree::State, type: :model do
-  describe 'Associations' do
-    it { is_expected.to have_many(:addresses).dependent(:restrict_with_error) }
-  end
-
-  describe 'validations' do
-    it { is_expected.to validate_presence_of(:name) }
-    it { is_expected.to validate_presence_of(:country) }
-    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:country_id).case_insensitive }
-    it { is_expected.to validate_uniqueness_of(:abbr).scoped_to(:country_id).case_insensitive }
-  end
-
-  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
-
-  describe 'whitelisted_ransackable_attributes' do
-    it { expect(Spree::State.whitelisted_ransackable_attributes).to eq(%w(abbr)) }
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe AvailabilityValidator, type: :model do
-      let!(:line_item) { double(quantity: 5, variant_id: 1, variant: double.as_null_object, errors: double('errors'), inventory_units: []) }
-      let(:inventory_unit) { double("InventoryUnit") }
-      let(:inventory_units) { [inventory_unit] }
-
-      subject { described_class.new }
-
-      before do
-        allow(inventory_unit).to receive_messages(quantity: 5)
-      end
-
-      it 'should be valid when supply is sufficient' do
-        allow_any_instance_of(Stock::Quantifier).to receive_messages(can_supply?: true)
-        expect(line_item).not_to receive(:errors)
-        subject.validate(line_item)
-      end
-
-      it 'should be invalid when supply is insufficent' do
-        allow_any_instance_of(Stock::Quantifier).to receive_messages(can_supply?: false)
-        expect(line_item.errors).to receive(:[]).with(:quantity).and_return []
-        subject.validate(line_item)
-      end
-
-      it 'should consider existing inventory_units sufficient' do
-        allow_any_instance_of(Stock::Quantifier).to receive_messages(can_supply?: false)
-        expect(line_item).not_to receive(:errors)
-        allow(line_item).to receive_messages(inventory_units: inventory_units)
-        subject.validate(line_item)
-      end
-
-      it 'should be valid when the quantity is zero' do
-        expect(line_item).to receive(:quantity).and_return(0)
-        expect(line_item.errors).to_not receive(:[]).with(:quantity)
-        subject.validate(line_item)
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe ContentItem, type: :model do
-      let(:variant) { build(:variant, weight: 25.0) }
-      subject { ContentItem.new(build(:inventory_unit, variant: variant)) }
-
-      describe 'Delegations' do
-        it { is_expected.to delegate_method(:line_item).to(:inventory_unit) }
-        it { is_expected.to delegate_method(:variant).to(:inventory_unit) }
-        it { is_expected.to delegate_method(:dimension).to(:variant).with_prefix }
-        it { is_expected.to delegate_method(:price).to(:variant) }
-        it { is_expected.to delegate_method(:volume).to(:variant).with_prefix }
-        it { is_expected.to delegate_method(:weight).to(:variant).with_prefix }
-      end
-
-      context "#volume" do
-        it "calculate the total volume of the variant" do
-          expect(subject.volume).to eq variant.volume * subject.quantity
-        end
-      end
-
-      context "#dimension" do
-        it "calculate the total dimension of the variant" do
-          expect(subject.dimension).to eq variant.dimension * subject.quantity
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Stock
-    describe Coordinator, type: :model do
-      let(:order) { create(:order_with_line_items) }
-
-      subject { Coordinator.new(order) }
-
-      context "packages" do
-        it "builds, prioritizes and estimates" do
-          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
-        let!(:stock_location1) { create(:stock_location, backorderable_default: false) }
-        let!(:stock_location2) { create(:stock_location, backorderable_default: false) }
-        let!(:product) { create(:product) }
-
-        let!(:order) do
-          product.stock_items.map { |stock_item| stock_item.adjust_count_on_hand(1) }
-          line_item = create(:line_item, product: product, quantity: 2)
-          line_item.order
-        end
-
-        it "builds a package for every stock location" do
-          expect(subject.build_packages.count).to eq(StockLocation.count)
-        end
-
-        context "missing stock items in stock location" do
-          let!(:another_location) { create(:stock_location, propagate_all_variants: false) }
-
-          it "builds packages only for valid stock locations" do
-            expect(subject.build_packages.count).to eq(StockLocation.count - 1)
-          end
-        end
-      end
-    end
-  end
-end