spree_core 3.1.5 → 3.1.6

data/spec/models/spree/line_item_spec.rb

@@ -1,327 +0,0 @@
-require 'spec_helper'
-
-describe Spree::LineItem, type: :model do
-  let(:order) { create :order_with_line_items, line_items_count: 1 }
-  let(:line_item) { order.line_items.first }
-
-  before { create(:store) }
-
-  describe 'Validations' do
-    it { expect(line_item).to validate_numericality_of(:quantity).only_integer.with_message(Spree.t('validation.must_be_int')) }
-  end
-
-  describe '#ensure_valid_quantity' do
-    context 'quantity.nil?' do
-      before do
-        line_item.quantity = nil
-        line_item.valid?
-      end
-
-      it { expect(line_item.quantity).to be_zero }
-    end
-
-    context 'quantity < 0' do
-      before do
-        line_item.quantity = -1
-        line_item.valid?
-      end
-
-      it { expect(line_item.quantity).to be_zero }
-    end
-
-    context 'quantity = 0' do
-      before do
-        line_item.quantity = 0
-        line_item.valid?
-      end
-
-      it { expect(line_item.quantity).to be_zero }
-    end
-
-    context 'quantity > 0' do
-      let(:original_quantity) { 1 }
-
-      before do
-        line_item.quantity = original_quantity
-        line_item.valid?
-      end
-
-      it { expect(line_item.quantity).to eq(original_quantity) }
-    end
-  end
-
-  context '#save' do
-    it 'touches the order' do
-      expect(line_item.order).to receive(:touch)
-      line_item.touch
-    end
-  end
-
-  context "#discontinued" do
-    it "fetches discontinued products" do
-      line_item.product.discontinue!
-      expect(line_item.reload.product).to be_a Spree::Product
-    end
-
-    it "fetches discontinued variants" do
-      line_item.variant.discontinue!
-      expect(line_item.reload.variant).to be_a Spree::Variant
-    end
-  end
-
-  context "#destroy" do
-    it "returns inventory when a line item is destroyed" do
-      expect_any_instance_of(Spree::OrderInventory).to receive(:verify)
-      line_item.destroy
-    end
-
-    it "deletes inventory units" do
-      expect { line_item.destroy }.to change { line_item.inventory_units.count }.from(1).to(0)
-    end
-  end
-
-  context "#save" do
-    context "line item changes" do
-      before do
-        line_item.quantity = line_item.quantity + 1
-      end
-
-      it "triggers adjustment total recalculation" do
-        expect(line_item).to receive(:update_tax_charge) # Regression test for https://github.com/spree/spree/issues/4671
-        expect(line_item).to receive(:recalculate_adjustments)
-        line_item.save
-      end
-    end
-
-    context "line item does not change" do
-      it "does not trigger adjustment total recalculation" do
-        expect(line_item).not_to receive(:recalculate_adjustments)
-        line_item.save
-      end
-    end
-
-    context "target_shipment is provided" do
-      it "verifies inventory" do
-        line_item.target_shipment = Spree::Shipment.new
-        expect_any_instance_of(Spree::OrderInventory).to receive(:verify)
-        line_item.save
-      end
-    end
-  end
-
-  context "#create" do
-    let(:variant) { create(:variant) }
-
-    before do
-      create(:tax_rate, zone: order.tax_zone, tax_category: variant.tax_category)
-    end
-
-    context "when order has a tax zone" do
-      before do
-        expect(order.tax_zone).to be_present
-      end
-
-      it "creates a tax adjustment" do
-        order.contents.add(variant)
-        line_item = order.find_line_item_by_variant(variant)
-        expect(line_item.adjustments.tax.count).to eq(1)
-      end
-    end
-
-    context "when order does not have a tax zone" do
-      before do
-        order.bill_address = nil
-        order.ship_address = nil
-        order.save
-        expect(order.reload.tax_zone).to be_nil
-      end
-
-      it "does not create a tax adjustment" do
-        order.contents.add(variant)
-        line_item = order.find_line_item_by_variant(variant)
-        expect(line_item.adjustments.tax.count).to eq(0)
-      end
-    end
-  end
-
-  # Test for #3391
-  context '#copy_price' do
-    it "copies over a variant's prices" do
-      line_item.price = nil
-      line_item.cost_price = nil
-      line_item.currency = nil
-      line_item.copy_price
-      variant = line_item.variant
-      expect(line_item.price).to eq(variant.price)
-      expect(line_item.cost_price).to eq(variant.cost_price)
-      expect(line_item.currency).to eq(variant.currency)
-    end
-  end
-
-  # test for copying prices when the vat changes
-  context "#update_price" do
-    it "copies over a variants differing price for another vat zone" do
-      expect(line_item.variant).to receive(:price_including_vat_for).and_return(12)
-      line_item.price = 10
-      line_item.update_price
-      expect(line_item.price).to eq(12)
-    end
-  end
-
-  # Test for #3481
-  context '#copy_tax_category' do
-    it "copies over a variant's tax category" do
-      line_item.tax_category = nil
-      line_item.copy_tax_category
-      expect(line_item.tax_category).to eq(line_item.variant.tax_category)
-    end
-  end
-
-  describe '#discounted_amount' do
-    it "returns the amount minus any discounts" do
-      line_item.price = 10
-      line_item.quantity = 2
-      line_item.taxable_adjustment_total = -5
-      expect(line_item.discounted_amount).to eq(15)
-    end
-  end
-
-  describe '.currency' do
-    it 'returns the globally configured currency' do
-      line_item.currency == 'USD'
-    end
-  end
-
-  describe "#discounted_money" do
-    it "should return a money object with the discounted amount" do
-      expect(line_item.discounted_money.to_s).to eq "$10.00"
-    end
-  end
-
-  describe "#money" do
-    before do
-      line_item.price = 3.50
-      line_item.quantity = 2
-    end
-
-    it "returns a Spree::Money representing the total for this line item" do
-      expect(line_item.money.to_s).to eq("$7.00")
-    end
-  end
-
-  describe '#single_money' do
-    before do
-      line_item.price = 3.50
-      line_item.quantity = 2
-    end
-
-    it "returns a Spree::Money representing the price for one variant" do
-      expect(line_item.single_money.to_s).to eq("$3.50")
-    end
-  end
-
-  context "has inventory (completed order so items were already unstocked)" do
-    let(:order) { Spree::Order.create(email: 'spree@example.com') }
-    let(:variant) { create(:variant) }
-
-    context "nothing left on stock" do
-      before do
-        variant.stock_items.update_all count_on_hand: 5, backorderable: false
-        order.contents.add(variant, 5)
-        order.create_proposed_shipments
-        order.finalize!
-      end
-
-      it "allows to decrease item quantity" do
-        line_item = order.line_items.first
-        line_item.quantity -= 1
-        line_item.target_shipment = order.shipments.first
-
-        line_item.save
-        expect(line_item.errors_on(:quantity).size).to eq(0)
-      end
-
-      it "doesnt allow to increase item quantity" do
-        line_item = order.line_items.first
-        line_item.quantity += 2
-        line_item.target_shipment = order.shipments.first
-
-        line_item.save
-        expect(line_item.errors_on(:quantity).size).to eq(1)
-      end
-    end
-
-    context "2 items left on stock" do
-      before do
-        variant.stock_items.update_all count_on_hand: 7, backorderable: false
-        order.contents.add(variant, 5)
-        order.create_proposed_shipments
-        order.finalize!
-      end
-
-      it "allows to increase quantity up to stock availability" do
-        line_item = order.line_items.first
-        line_item.quantity += 2
-        line_item.target_shipment = order.shipments.first
-
-        line_item.save
-        expect(line_item.errors_on(:quantity).size).to eq(0)
-      end
-
-      it "doesnt allow to increase quantity over stock availability" do
-        line_item = order.line_items.first
-        line_item.quantity += 3
-        line_item.target_shipment = order.shipments.first
-
-        line_item.save
-        expect(line_item.errors_on(:quantity).size).to eq(1)
-      end
-    end
-  end
-
-  context "currency same as order.currency" do
-    it "is a valid line item" do
-      line_item = order.line_items.first
-      line_item.currency = order.currency
-      line_item.valid?
-
-      expect(line_item.error_on(:currency).size).to eq(0)
-    end
-  end
-
-  context "currency different than order.currency" do
-    it "is not a valid line item" do
-      line_item = order.line_items.first
-      line_item.currency = "no currency"
-      line_item.valid?
-
-      expect(line_item.error_on(:currency).size).to eq(1)
-    end
-  end
-
-  describe "#options=" do
-    it "can handle updating a blank line item with no order" do
-      line_item.options = { price: 123 }
-    end
-
-    it "updates the data provided in the options" do
-      line_item.options = { price: 123 }
-      expect(line_item.price).to eq 123
-    end
-
-    it "updates the price based on the options provided" do
-      expect(line_item).to receive(:gift_wrap=).with(true)
-      expect(line_item.variant).to receive(:gift_wrap_price_modifier_amount_in).with("USD", true).and_return 1.99
-      line_item.options = { gift_wrap: true }
-      expect(line_item.price).to eq 21.98
-    end
-  end
-
-  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
-end

data/spec/models/spree/option_type_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Spree::OptionType, :type => :model do
-  context "touching" do
-    it "should touch a product" do
-      product_option_type = create(:product_option_type)
-      option_type = product_option_type.option_type
-      product = product_option_type.product
-      product.update_column(:updated_at, 1.day.ago)
-      option_type.touch
-      expect(product.reload.updated_at).to be_within(3.seconds).of(Time.current)
-    end
-  end
-end

data/spec/models/spree/option_value_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Spree::OptionValue, type: :model do
-  describe 'delegate' do
-    it { is_expected.to delegate_method(:name).to(:option_type).with_prefix }
-    it { is_expected.to delegate_method(:presentation).to(:option_type).with_prefix }
-  end
-
-  context "touching" do
-    it "should touch a variant" do
-      variant = create(:variant)
-      option_value = variant.option_values.first
-      variant.update_column(:updated_at, 1.day.ago)
-      option_value.touch
-      expect(variant.reload.updated_at).to be_within(3.seconds).of(Time.current)
-    end
-  end
-end

data/spec/models/spree/order/address_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, :type => :model do
-  let(:order) { Spree::Order.new }
-
-  context 'validation' do
-    context "when @use_billing is populated" do
-      before do
-        order.bill_address = stub_model(Spree::Address)
-        order.ship_address = nil
-      end
-
-      context "with true" do
-        before { order.use_billing = true }
-
-        it "clones the bill address to the ship address" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with 'true'" do
-        before { order.use_billing = 'true' }
-
-        it "clones the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with '1'" do
-        before { order.use_billing = '1' }
-
-        it "clones the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with something other than a 'truthful' value" do
-        before { order.use_billing = '0' }
-
-        it "does not clone the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/order/adjustments_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order do
-  context "when an order has an adjustment that zeroes the total, but another adjustment for shipping that raises it above zero" do
-    let!(:persisted_order) { create(:order) }
-    let!(:line_item) { create(:line_item) }
-    let!(:shipping_method) do
-      sm = create(:shipping_method)
-      sm.calculator.preferred_amount = 10
-      sm.save
-      sm
-    end
-
-    before do
-      # Don't care about available payment methods in this test
-      allow(persisted_order).to receive_messages(:has_available_payment => false)
-      persisted_order.line_items << line_item
-      create(:adjustment, amount: -line_item.amount, label: "Promotion", adjustable: line_item, order: persisted_order)
-      persisted_order.state = 'delivery'
-      persisted_order.save # To ensure new state_change event
-    end
-
-    it "transitions from delivery to payment" do
-      allow(persisted_order).to receive_messages(payment_required?: true)
-      persisted_order.next!
-      expect(persisted_order.state).to eq("payment")
-    end
-  end
-end

data/spec/models/spree/order/callbacks_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, :type => :model do
-  let(:order) { stub_model(Spree::Order) }
-  before do
-    Spree::Order.define_state_machine!
-  end
-
-  context "validations" do
-    context "email validation" do
-      # Regression test for #1238
-      it "o'brien@gmail.com is a valid email address" do
-        order.state = 'address'
-        order.email = "o'brien@gmail.com"
-        expect(order.error_on(:email).size).to eq(0)
-      end
-    end
-  end
-
-  context "#save" do
-    context "when associated with a registered user" do
-      let(:user) { double(:user, :email => "test@example.com") }
-
-      before do
-        allow(order).to receive_messages :user => user
-      end
-
-      it "should assign the email address of the user" do
-        order.run_callbacks(:create)
-        expect(order.email).to eq(user.email)
-      end
-    end
-  end
-
-  context "in the cart state" do
-    it "should not validate email address" do
-      order.state = "cart"
-      order.email = nil
-      expect(order.error_on(:email).size).to eq(0)
-    end
-  end
-end