solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/order_merger_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# Regression tests for https://github.com/spree/spree/issues/2179
+module Spree
+  RSpec.describe OrderMerger, type: :model do
+    let(:variant) { create(:variant) }
+    let!(:store) { create(:store, default: true) }
+    let(:order_1) { Spree::Order.create }
+    let(:order_2) { Spree::Order.create }
+    let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }
+    let(:subject) { Spree::OrderMerger.new(order_1) }
+
+    it "destroys the other order" do
+      subject.merge!(order_2)
+      expect { order_2.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it "persist the merge" do
+      expect(subject).to receive(:persist_merge)
+      subject.merge!(order_2)
+    end
+
+    context "user is provided" do
+      it "assigns user to new order" do
+        subject.merge!(order_2, user)
+        expect(order_1.user).to eq user
+      end
+    end
+
+    context "merging together two orders with line items for the same variant" do
+      before do
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant, 1)
+      end
+
+      specify do
+        subject.merge!(order_2, user)
+        expect(order_1.line_items.count).to eq(1)
+
+        line_item = order_1.line_items.first
+        expect(line_item.quantity).to eq(2)
+        expect(line_item.variant_id).to eq(variant.id)
+      end
+    end
+
+    context 'merging together two orders with multiple currencies line items' do
+      let(:order_2) { Spree::Order.create(currency: 'JPY') }
+      let(:variant_2) { create(:variant) }
+
+      before do
+        Spree::Price.create(variant: variant_2, amount: 10, currency: 'JPY')
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant_2.reload, 1)
+      end
+
+      it 'rejects other order line items' do
+        subject.merge!(order_2, user)
+        expect(order_1.line_items.count).to eq(1)
+
+        line_item = order_1.line_items.first
+        expect(line_item.quantity).to eq(1)
+        expect(line_item.variant_id).to eq(variant.id)
+      end
+    end
+
+    context "merging using extension-specific line_item_comparison_hooks" do
+      before do
+        Spree::Order.register_line_item_comparison_hook(:foos_match)
+        allow(Spree::Variant).to receive(:price_modifier_amount).and_return(0.00)
+      end
+
+      after do
+        # reset to avoid test pollution
+        Spree::Order.line_item_comparison_hooks = Set.new
+      end
+
+      context "2 equal line items" do
+        before do
+          @line_item_1 = order_1.contents.add(variant, 1, foos: {})
+          @line_item_2 = order_2.contents.add(variant, 1, foos: {})
+        end
+
+        specify do
+          expect(order_1).to receive(:foos_match).with(@line_item_1, kind_of(Hash)).and_return(true)
+          subject.merge!(order_2)
+          expect(order_1.line_items.count).to eq(1)
+
+          line_item = order_1.line_items.first
+          expect(line_item.quantity).to eq(2)
+          expect(line_item.variant_id).to eq(variant.id)
+        end
+      end
+
+      context "2 different line items" do
+        before do
+          allow(order_1).to receive(:foos_match).and_return(false)
+
+          order_1.contents.add(variant, 1, foos: {})
+          order_2.contents.add(variant, 1, foos: { bar: :zoo })
+        end
+
+        specify do
+          subject.merge!(order_2)
+          expect(order_1.line_items.count).to eq(2)
+
+          line_item = order_1.line_items.first
+          expect(line_item.quantity).to eq(1)
+          expect(line_item.variant_id).to eq(variant.id)
+
+          line_item = order_1.line_items.last
+          expect(line_item.quantity).to eq(1)
+          expect(line_item.variant_id).to eq(variant.id)
+        end
+      end
+    end
+
+    context "merging together two orders with different line items" do
+      let(:variant_2) { create(:variant) }
+
+      before do
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant_2, 1)
+      end
+
+      specify do
+        subject.merge!(order_2)
+
+        # Both in memory and in DB line items
+        expect(order_1.line_items.length).to eq(2)
+        expect(order_1.line_items.count).to eq(2)
+
+        expect(order_1.item_count).to eq 2
+        expect(order_1.item_total).to eq order_1.line_items.map(&:amount).sum
+
+        # No guarantee on ordering of line items, so we do this:
+        expect(order_1.line_items.pluck(:quantity)).to match_array([1, 1])
+        expect(order_1.line_items.pluck(:variant_id)).to match_array([variant.id, variant_2.id])
+      end
+    end
+
+    context "merging together orders with invalid line items" do
+      let(:variant_2) { create(:variant) }
+
+      before do
+        order_1.contents.add(variant, 1)
+        order_2.contents.add(variant_2, 1)
+      end
+
+      it "should create errors with invalid line items" do
+        variant_2.really_destroy!
+        order_2.line_items.to_a.first.reload # so that it registers as invalid
+        subject.merge!(order_2)
+        expect(order_1.errors.full_messages).not_to be_empty
+      end
+    end
+  end
+end

data/spec/models/spree/order_mutex_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::OrderMutex do
+  include ActiveSupport::Testing::TimeHelpers
+
+  let(:order) { create(:order) }
+
+  context "without an existing lock" do
+    it "executes the block" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+
+    it "releases the lock for subsequent calls" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.twice
+    end
+
+    it "returns the value of the block" do
+      expect(Spree::OrderMutex.with_lock!(order) { 'yay for spree' }).to eq 'yay for spree'
+    end
+  end
+
+  context "with an existing lock on the same order" do
+    it "raises a LockFailed error and then releases the lock" do
+      Spree::OrderMutex.with_lock!(order) do
+        expect {
+          expect { |b|
+            Spree::OrderMutex.with_lock!(order, &b)
+          }.not_to yield_control
+        }.to raise_error(Spree::OrderMutex::LockFailed)
+      end
+
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+  end
+
+  context "with an expired existing lock on the same order" do
+    around do |example|
+      Spree::OrderMutex.with_lock!(order) do
+        future = Spree::Config[:order_mutex_max_age].seconds.from_now + 1.second
+        travel_to(future) do
+          example.run
+        end
+      end
+    end
+
+    it "executes the block" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+  end
+
+  context "with an existing lock on a different order" do
+    let(:order2) { create(:order) }
+
+    around do |example|
+      Spree::OrderMutex.with_lock!(order2) { example.run }
+    end
+
+    it "executes the block" do
+      expect { |b|
+        Spree::OrderMutex.with_lock!(order, &b)
+      }.to yield_control.once
+    end
+  end
+
+  context "when an unrelated RecordNotUnique error occurs" do
+    def raise_record_not_unique
+      raise ActiveRecord::RecordNotUnique.new("Testing")
+    end
+
+    it "does not rescue the unrelated error" do
+      expect {
+        Spree::OrderMutex.with_lock!(order) do
+          raise_record_not_unique
+        end
+      }.to raise_error(ActiveRecord::RecordNotUnique)
+    end
+  end
+end

data/spec/models/spree/order_promotion_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::OrderPromotion do
+  subject do
+    order_promotion
+  end
+
+  let(:order_promotion) { build(:order_promotion) }
+
+  describe "promotion code presence error" do
+    subject do
+      order_promotion.valid?
+      order_promotion.errors[:promotion_code]
+    end
+
+    let(:order_promotion) { build(:order_promotion) }
+    let(:promotion) { order_promotion.promotion }
+
+    context "when the promotion does not have a code" do
+      it { is_expected.to be_blank }
+    end
+
+    context "when the promotion has a code" do
+      let!(:promotion_code) do
+        promotion.codes << build(:promotion_code, promotion: promotion)
+      end
+
+      it { is_expected.to include("can't be blank") }
+    end
+  end
+end

data/spec/models/spree/order_shipping_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::OrderShipping do
+  include ActiveSupport::Testing::TimeHelpers
+
+  let(:order) { create(:order_ready_to_ship, line_items_count: 1) }
+
+  def emails
+    ActionMailer::Base.deliveries
+  end
+
+  shared_examples 'shipment shipping' do
+    it "marks the inventory units as shipped" do
+      expect { subject }.to change { order.inventory_units.reload.map(&:state) }.from(['on_hand']).to(['shipped'])
+    end
+
+    it "creates a carton with the shipment's inventory units" do
+      expect { subject }.to change { order.cartons.count }.by(1)
+      expect(subject.inventory_units).to match_array(shipment.inventory_units)
+    end
+
+    describe "shipment email" do
+      it "should send a shipment email" do
+        expect {
+          perform_enqueued_jobs {
+            subject
+          }
+        }.to change { emails.size }.by(1)
+        expect(emails.last.subject).to eq("#{order.store.name} Shipment Notification ##{order.number}")
+      end
+    end
+
+    it "updates the order shipment state" do
+      expect { subject }.to change { order.reload.shipment_state }.from('ready').to('shipped')
+    end
+
+    it "updates shipment.shipped_at" do
+      now = Time.current
+      travel_to(now) do
+        expect { subject }.to change { shipment.shipped_at }.from(nil).to be_within(1.second).of(now)
+      end
+    end
+
+    it "updates order.updated_at" do
+      future = 1.minute.from_now
+      expect do
+        travel_to(future) do
+          subject
+        end
+      end.to change { order.updated_at }.to be_within(1.second).of(future)
+    end
+  end
+
+  describe "#ship" do
+    subject do
+      order.shipping.ship(
+        inventory_units: inventory_units,
+        stock_location: stock_location,
+        address: address,
+        shipping_method: shipping_method
+      )
+    end
+
+    let(:shipment) { order.shipments.to_a.first }
+    let(:inventory_units) { shipment.inventory_units }
+    let(:stock_location) { shipment.stock_location }
+    let(:address) { order.ship_address }
+    let(:shipping_method) { shipment.shipping_method }
+
+    it_behaves_like 'shipment shipping'
+
+    context "with an external_number" do
+      subject do
+        order.shipping.ship(
+          inventory_units: inventory_units,
+          stock_location: stock_location,
+          address: address,
+          shipping_method: shipping_method,
+          external_number: 'some-external-number'
+        )
+      end
+
+      it "sets the external_number" do
+        expect(subject.external_number).to eq 'some-external-number'
+      end
+    end
+
+    context "with a tracking number" do
+      subject do
+        order.shipping.ship(
+          inventory_units: inventory_units,
+          stock_location: stock_location,
+          address: address,
+          shipping_method: shipping_method,
+          tracking_number: 'tracking-number'
+        )
+      end
+
+      it "sets the tracking-number" do
+        expect(subject.tracking).to eq 'tracking-number'
+      end
+    end
+
+    context "when told to suppress the mailer" do
+      subject do
+        order.shipping.ship(
+          inventory_units: inventory_units,
+          stock_location: stock_location,
+          address: address,
+          shipping_method: shipping_method,
+          suppress_mailer: true
+        )
+      end
+
+      it "does not send a shipment email" do
+        expect { subject }.to_not change { emails.size }
+      end
+    end
+  end
+
+  describe "#ship_shipment" do
+    subject { order.shipping.ship_shipment(shipment) }
+
+    let(:shipment) { order.shipments.to_a.first }
+
+    it_behaves_like 'shipment shipping'
+
+    context "when not all units are shippable" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
+      let(:shippable_line_item) { order.line_items.first }
+      let(:unshippable_line_item) { order.line_items.last }
+
+      before do
+        unshippable_line_item.inventory_units.each(&:cancel!)
+      end
+
+      it "only ships the shippable ones" do
+        expect(subject.inventory_units).to match_array(shippable_line_item.inventory_units)
+      end
+    end
+
+    context "when all units are canceled or shipped" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
+
+      before { Spree::OrderCancellations.new(order).short_ship([order.inventory_units.first]) }
+
+      it "updates the order shipment state" do
+        expect { subject }.to change { order.reload.shipment_state }.from('ready').to('shipped')
+      end
+    end
+
+    context "with an external_number" do
+      subject do
+        order.shipping.ship_shipment(
+          shipment,
+          external_number: 'some-external-number'
+        )
+      end
+
+      it "sets the external_number" do
+        expect(subject.external_number).to eq 'some-external-number'
+      end
+    end
+
+    context "with a tracking number" do
+      subject do
+        order.shipping.ship_shipment(
+          shipment,
+          tracking_number: 'tracking-number'
+        )
+      end
+
+      it "sets the tracking-number" do
+        expect(subject.tracking).to eq 'tracking-number'
+      end
+    end
+
+    # TODO: We can remove this once Shipment#ship! is called by
+    # OrderShipping#ship rather than vice versa
+    context "when the tracking number is already on the shipment" do
+      before do
+        shipment.update_attributes!(tracking: 'tracking-number')
+      end
+
+      it "sets the tracking-number" do
+        expect(subject.tracking).to eq 'tracking-number'
+      end
+    end
+
+    context "when the shipment has been partially shipped previously" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
+      let(:inventory_units) { shipment.inventory_units.to_a }
+      let(:shipped_inventory) { [inventory_units.first] }
+      let(:unshipped_inventory) { [inventory_units.last] }
+
+      before do
+        order.shipping.ship(
+          inventory_units: shipped_inventory,
+          stock_location: shipment.stock_location,
+          address: order.ship_address,
+          shipping_method: shipment.shipping_method
+        )
+      end
+
+      it "marks the inventory units as shipped" do
+        expect { subject }.to change { unshipped_inventory.map(&:reload).map(&:state) }.from(['on_hand']).to(['shipped'])
+      end
+
+      it "creates a carton with the shipment's inventory units" do
+        expect { subject }.to change { order.cartons.count }.by(1)
+        expect(subject.inventory_units).to match_array(unshipped_inventory)
+      end
+    end
+
+    context "when told to suppress the mailer" do
+      subject do
+        order.shipping.ship_shipment(
+          shipment,
+          suppress_mailer: true
+        )
+      end
+
+      it "does not send a shipment email" do
+        expect { subject }.to_not change { emails.size }
+      end
+    end
+
+    context "with stale inventory units (regression test)" do
+      let(:order) { FactoryBot.create(:order_ready_to_ship, line_items_count: 1) }
+      let(:shipment) do
+        FactoryBot.create(
+          :shipment,
+          order: order
+        )
+      end
+
+      before { shipment.ready! }
+
+      it "updates the state to shipped" do
+        order.shipping.ship_shipment(shipment)
+        expect(shipment.reload.state).to eq "shipped"
+      end
+    end
+  end
+end