solidus_core 2.1.1 → 2.2.0.beta1

data/spec/models/spree/payment_method_spec.rb

@@ -67,6 +67,22 @@ describe Spree::PaymentMethod, type: :model do
 
       it { is_expected.to contain_exactly(payment_method_back_display, payment_method_both_display, payment_method_nil_display)}
     end
+
+    context "when searching for payment methods available to a store" do
+      subject { Spree::PaymentMethod.available_to_store(store) }
+
+      context "when the store is nil" do
+        let(:store) { nil }
+        it "raises an argument error" do
+          expect { subject }.to raise_error(ArgumentError, "You must provide a store")
+        end
+      end
+
+      context "when the store exists" do
+        let(:store) { create(:store, payment_methods: [payment_method_back_display]) }
+        it { is_expected.to contain_exactly(payment_method_back_display) }
+      end
+    end
   end
 
   describe ".available" do

data/spec/models/spree/payment_spec.rb

@@ -653,13 +653,12 @@ describe Spree::Payment, type: :model do
     end
 
     context "completed orders" do
-      let(:payment_method) { create(:check_payment_method) }
       before { allow(order).to receive_messages completed?: true }
 
       it "updates payment_state and shipments" do
         expect(order.updater).to receive(:update_payment_state)
         expect(order.updater).to receive(:update_shipment_state)
-        Spree::Payment.create!(amount: 100, order: order, payment_method: payment_method)
+        Spree::Payment.create(amount: 100, order: order)
       end
     end
 
@@ -743,13 +742,12 @@ describe Spree::Payment, type: :model do
     end
 
     describe "invalidating payments updates in memory objects" do
-      let(:payment_method) { create(:check_payment_method) }
       before do
-        Spree::PaymentCreate.new(order, amount: 1, payment_method_id: payment_method.id).build.save!
+        Spree::PaymentCreate.new(order, amount: 1).build.save!
         expect(order.payments.map(&:state)).to contain_exactly(
           'checkout'
         )
-        Spree::PaymentCreate.new(order, amount: 2, payment_method_id: payment_method.id).build.save!
+        Spree::PaymentCreate.new(order, amount: 2).build.save!
       end
 
       it 'should not have stale payments' do
@@ -808,11 +806,12 @@ describe Spree::Payment, type: :model do
       let(:order) { create(:order, user: user) }
       let(:user) { create(:user) }
       let!(:credit_card) { create(:credit_card, user_id: order.user_id) }
+      let!(:wallet_payment_source) { user.wallet.add(credit_card) }
 
       let(:params) do
         {
           source_attributes: {
-            existing_card_id: credit_card.id,
+            wallet_payment_source_id: wallet_payment_source.id,
             verification_value: '321'
           }
         }
@@ -849,14 +848,21 @@ describe Spree::Payment, type: :model do
 
         context 'the credit card belongs to a different user' do
           let(:other_user) { create(:user) }
-          before { credit_card.update!(user_id: other_user.id) }
+          before do
+            credit_card.update!(user_id: other_user.id)
+            user.wallet.remove(credit_card)
+            other_user.wallet.add(credit_card)
+          end
           it 'errors' do
             expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
           end
         end
 
         context 'the credit card has no user' do
-          before { credit_card.update!(user_id: nil) }
+          before do
+            credit_card.update!(user_id: nil)
+            user.wallet.remove(credit_card)
+          end
           it 'errors' do
             expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
           end

data/spec/models/spree/promotion_code/batch_builder_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe Spree::PromotionCode::BatchBuilder do
+  let(:promotion) { create(:promotion) }
+  let(:base_code) { "abc" }
+  let(:promotion_code_batch) do
+    Spree::PromotionCodeBatch.create!(
+      promotion_id: promotion.id,
+      base_code: base_code,
+      number_of_codes: 10,
+      email: "test@email.com"
+    )
+  end
+
+  subject { described_class.new promotion_code_batch }
+
+  describe "#build_promotion_codes" do
+    context "with a failed build" do
+      before do
+        allow(subject).to receive(:generate_random_codes).and_raise "Error"
+
+        expect { subject.build_promotion_codes }.to raise_error RuntimeError
+      end
+
+      it "updates the error and state on promotion batch" do
+        expect(promotion_code_batch.reload.error).to eq("#<RuntimeError: Error>")
+        expect(promotion_code_batch.reload.state).to eq("failed")
+      end
+    end
+    context "with a successful build" do
+      before do
+        allow(Spree::PromotionCodeBatchMailer)
+          .to receive(:promotion_code_batch_finished)
+          .and_call_original
+
+        subject.build_promotion_codes
+      end
+
+      it "update the promotion codes count for the batch" do
+        expect(promotion_code_batch.promotion_codes.count).to eq(10)
+      end
+
+      it "builds the correct number of codes" do
+        expect(subject.promotion.codes.size).to eq(10)
+      end
+
+      it "builds codes with distinct values" do
+        expect(subject.promotion.codes.map(&:value).uniq.size).to eq(10)
+      end
+
+      it "builds codes with the same base prefix" do
+        values = subject.promotion.codes.map(&:value)
+        expect(values.all? { |val| val.starts_with?("#{base_code}_") }).to be true
+      end
+
+      it "updates the promotion code batch state to completed" do
+        expect(promotion_code_batch.state).to eq("completed")
+      end
+    end
+  end
+end

data/spec/models/spree/promotion_code_batch_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Spree::PromotionCodeBatch, type: :model do
+  include ActiveJob::TestHelper
+
+  subject do
+    described_class.create!(
+      promotion_id: create(:promotion).id,
+      base_code: "abc",
+      number_of_codes: 1,
+      error: nil,
+      email: "test@email.com"
+    )
+  end
+
+  describe "#process" do
+    context "with a pending code batch" do
+      it "should call the worker" do
+        ActiveJob::Base.queue_adapter = :test
+
+        expect { subject.process }
+          .to have_enqueued_job(Spree::PromotionCodeBatchJob)
+
+        clear_enqueued_jobs
+      end
+
+      it "should update the state to processing" do
+        subject.process
+
+        expect(subject.state).to eq("processing")
+      end
+    end
+
+    context "with a processing batch" do
+      before { subject.update_attribute(:state, "processing") }
+
+      it "should raise an error" do
+        expect{ subject.process }.to raise_error Spree::PromotionCodeBatch::CantProcessStartedBatch
+      end
+    end
+
+    context "with a completed batch" do
+      before { subject.update_attribute(:state, "completed") }
+
+      it "should raise an error" do
+        expect{ subject.process }.to raise_error Spree::PromotionCodeBatch::CantProcessStartedBatch
+      end
+    end
+
+    context "with a failed batch" do
+      before { subject.update_attribute(:state, "failed") }
+
+      it "should raise an error" do
+        expect{ subject.process }.to raise_error Spree::PromotionCodeBatch::CantProcessStartedBatch
+      end
+    end
+  end
+end

data/spec/models/spree/promotion_code_spec.rb

@@ -164,21 +164,25 @@ RSpec.describe Spree::PromotionCode do
         order.complete!
       end
     end
+
     it "makes the promotion ineligible" do
       expect{
         order.complete
       }.to change{ promo_adjustment.reload.eligible }.to(false)
     end
+
     it "adjusts the promo_total" do
       expect{
         order.complete
       }.to change(order, :promo_total).by(10)
     end
+
     it "increases the total to remove the promo" do
       expect{
         order.complete
       }.to change(order, :total).from(30).to(40)
     end
+
     it "resets the state of the order" do
       expect{
         order.complete

data/spec/models/spree/promotion_spec.rb

@@ -597,8 +597,7 @@ describe Spree::Promotion, type: :model do
           allow(rule2).to receive_messages(eligible?: true, applicable?: true)
 
           promotion.promotion_rules = [rule1, rule2]
-          allow(promotion).to receive_message_chain(:rules, :none?).and_return(false)
-          allow(promotion).to receive_message_chain(:rules, :for).and_return(promotion.promotion_rules)
+          allow(promotion.promotion_rules).to receive(:for).and_return(promotion.promotion_rules)
         end
         it "returns the eligible rules" do
           expect(promotion.eligible_rules(promotable)).to eq [rule1, rule2]
@@ -616,8 +615,7 @@ describe Spree::Promotion, type: :model do
           allow(rule2).to receive_messages(eligible?: false, applicable?: true, eligibility_errors: errors)
 
           promotion.promotion_rules = [rule1, rule2]
-          allow(promotion).to receive_message_chain(:rules, :none?).and_return(false)
-          allow(promotion).to receive_message_chain(:rules, :for).and_return(promotion.promotion_rules)
+          allow(promotion.promotion_rules).to receive(:for).and_return(promotion.promotion_rules)
         end
         it "returns nil" do
           expect(promotion.eligible_rules(promotable)).to be_nil
@@ -649,8 +647,7 @@ describe Spree::Promotion, type: :model do
           allow(rule).to receive_messages(eligible?: false, applicable?: true, eligibility_errors: errors)
 
           promotion.promotion_rules = [rule]
-          allow(promotion).to receive_message_chain(:rules, :for).and_return(promotion.promotion_rules)
-          allow(promotion).to receive_message_chain(:rules, :none?).and_return(false)
+          allow(promotion.promotion_rules).to receive(:for).and_return(promotion.promotion_rules)
         end
         it "returns nil" do
           expect(promotion.eligible_rules(promotable)).to be_nil

data/spec/models/spree/return_authorization_spec.rb

@@ -44,65 +44,6 @@ describe Spree::ReturnAuthorization, type: :model do
         expect(return_authorization.errors['base'].size).to eq 0
       end
     end
-
-    context "expedited exchanges are configured" do
-      let(:order)                { create(:shipped_order, line_items_count: 2) }
-      let(:exchange_return_item) { build(:exchange_return_item, inventory_unit: order.inventory_units.first) }
-      let(:return_item)          { build(:return_item, inventory_unit: order.inventory_units.last) }
-      subject                    { create(:return_authorization, order: order, return_items: [exchange_return_item, return_item]) }
-
-      before do
-        Spree::Config[:expedited_exchanges] = true
-        @pre_exchange_hooks = subject.class.pre_expedited_exchange_hooks
-      end
-
-      after do
-        subject.class.pre_expedited_exchange_hooks = @pre_exchange_hooks
-      end
-
-      context "no items to exchange" do
-        subject { create(:return_authorization, order: order) }
-
-        it "does not create a reimbursement" do
-          expect{ subject.save }.to_not change { Spree::Reimbursement.count }
-        end
-      end
-
-      context "items to exchange" do
-        it "calls pre_expedited_exchange hooks with the return items to exchange" do
-          hook = double(:as_null_object)
-          expect(hook).to receive(:call).with [exchange_return_item]
-          subject.class.pre_expedited_exchange_hooks = [hook]
-          subject.save
-        end
-
-        it "attempts to accept all return items requiring exchange" do
-          expect(exchange_return_item).to receive :attempt_accept
-          expect(return_item).not_to receive :attempt_accept
-          subject.save
-        end
-
-        it "performs an exchange reimbursement for the exchange return items" do
-          subject.save
-          reimbursement = Spree::Reimbursement.last
-          expect(reimbursement.order).to eq subject.order
-          expect(reimbursement.return_items).to eq [exchange_return_item]
-          expect(exchange_return_item.reload.exchange_shipment).to be_present
-        end
-
-        context "the reimbursement fails" do
-          before do
-            allow_any_instance_of(Spree::Reimbursement).to receive(:save) { false }
-            allow_any_instance_of(Spree::Reimbursement).to receive(:errors) { double(full_messages: "foo") }
-          end
-
-          it "puts errors on the return authorization" do
-            subject.save
-            expect(subject.errors[:base]).to include "foo"
-          end
-        end
-      end
-    end
   end
 
   describe ".before_create" do

data/spec/models/spree/shipment_spec.rb

@@ -724,11 +724,10 @@ describe Spree::Shipment, type: :model do
       expect { shipment.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    it "cannot be destroyed when ready" do
+    it "can be destroyed when ready" do
       shipment = create(:shipment, state: "ready")
-      expect(shipment.destroy).to eq false
-      expect(shipment.errors.full_messages.join).to match /Cannot destroy/
-      expect { shipment.reload }.not_to raise_error
+      expect(shipment.destroy).to be_truthy
+      expect { shipment.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
     it "cannot be destroyed when shipped" do
@@ -753,6 +752,7 @@ describe Spree::Shipment, type: :model do
     before do
       stock_item.set_count_on_hand(10)
       stock_item.update_attributes!(backorderable: false)
+      inventory_unit.update_attributes!(pending: true)
     end
 
     subject { shipment.finalize! }

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

@@ -26,6 +26,7 @@ module Spree
         end
 
         it "doesn't add a validation error" do
+          subject
           expect(line_item.errors).to be_empty
         end
       end
@@ -53,28 +54,82 @@ module Spree
       context "line_item is part of a shipment" do
         let!(:order) { create(:order_with_line_items) }
 
-        context "has stock in all stock locations" do
+        context "has stock in one stock location" do
           let(:line_item)         { order.line_items.first }
 
           before do
-            variant_ids = order.line_items.map(&:variant_id)
-            Spree::StockItem.where(variant_id: variant_ids).update_all(count_on_hand: 10, backorderable: false)
+            line_item.variant.stock_items.update_all(count_on_hand: 10, backorderable: false)
           end
 
           include_examples "passes validation"
         end
 
-        context "doesn't have stock in a particular stock location" do
-          let(:variant)           { create(:variant) }
-          let(:line_item)         { order.line_items.find_by(variant_id: variant.id) }
+        context "with stock in multiple locations" do
+          let(:line_item)         { order.line_items.first }
+          let(:variant)           { line_item.variant }
           let!(:stock_location_1) { create(:stock_location, name: "Test Warehouse", active: false) }
 
           before do
-            order.contents.add(variant, 1, stock_location_quantities: { stock_location_1.id => 1 })
-            order.contents.advance
-            stock_location_1.stock_items.update_all(count_on_hand: 0, backorderable: false)
+            shipment = order.shipments.create(stock_location: stock_location_1)
+            order.contents.add(variant, 1, shipment: shipment)
+          end
+
+          context "but no stock in either location" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 0, backorderable: false)
+            end
+            include_examples "fails validation"
+          end
+
+          context "but no stock in one location" do
+            before do
+              stock_location_1.stock_items.update_all(count_on_hand: 0, backorderable: false)
+            end
+
+            include_examples "fails validation"
+          end
+
+          context "with enough stock only across locations" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 1, backorderable: false)
+            end
+            include_examples "passes validation"
+          end
+
+          context "but inventory units are finalized" do
+            before do
+              order.inventory_units.update_all(pending: false)
+            end
+
+            include_examples "passes validation"
           end
+        end
+      end
+
+      context "line_item is split across two shipments" do
+        let!(:order) { create(:order_with_line_items) }
+        let(:line_item) { order.line_items.first }
+        let(:variant) { line_item.variant }
+        let(:stock_location) { order.shipments.first.stock_location }
+
+        before do
+          shipment2 = order.shipments.create!(stock_location: order.shipments.first.stock_location)
+          order.contents.add(variant, 1, shipment: shipment2)
+          variant.stock_items.first.update_columns(count_on_hand: count_on_hand, backorderable: false)
+        end
+
+        context "and there is just enough stock" do
+          let(:count_on_hand) { 2 }
+          include_examples "passes validation"
+        end
+
+        context "and there is not enough stock" do
+          let(:count_on_hand) { 1 }
+          include_examples "fails validation"
+        end
 
+        context "and there is no available stock" do
+          let(:count_on_hand) { 0 }
           include_examples "fails validation"
         end
       end

data/spec/models/spree/tax/item_adjuster_spec.rb

@@ -65,13 +65,12 @@ RSpec.describe Spree::Tax::ItemAdjuster do
 
       context 'when there are matching rates for the zone' do
         context 'and all rates have the same tax category as the item' do
+          let(:item) { build_stubbed :line_item, order: order, tax_category: item_tax_category }
           let(:item_tax_category) { build_stubbed(:tax_category) }
           let(:rate_1) { create :tax_rate, tax_category: item_tax_category }
           let(:rate_2) { create :tax_rate }
           let(:rates_for_order_zone) { [rate_1, rate_2] }
 
-          before { allow(item).to receive(:tax_category).and_return(item_tax_category) }
-
           it 'creates an adjustment for every matching rate' do
             adjuster.adjust!
             expect(tax_adjustments.length).to eq(1)

data/spec/models/spree/unit_cancel_spec.rb

@@ -55,90 +55,5 @@ describe Spree::UnitCancel do
         expect { subject }.to raise_error RuntimeError, "Adjustable does not match line item"
       end
     end
-
-    context "when exchanges are present" do
-      let!(:order) { create(:order, ship_address: create(:address)) }
-      let!(:product) { create(:product, price: 10.00) }
-      let!(:variant) do
-        create(:variant, price: 10, product: product, track_inventory: false)
-      end
-      let!(:shipping_method) { create(:free_shipping_method) }
-      let(:exchange_variant) do
-        create(:variant, product: variant.product, price: 10, track_inventory: false)
-      end
-
-      before do
-        Spree::Config[:expedited_exchanges] = true
-      end
-
-      # This sets up an order with one shipped inventory unit, one unshipped
-      # inventory unit, and one unshipped exchange inventory unit.
-      before do
-        # Complete an order with 1 line item with quantity=2
-        order.contents.add(variant, 2)
-        order.contents.advance
-        create(:payment, order: order, amount: order.total)
-        order.payments.reload
-        order.contents.advance
-        order.complete!
-        order.reload
-
-        # Ship _one_ of the inventory units
-        @shipment = order.shipments.first
-        @shipped_inventory_unit = order.inventory_units[0]
-        @unshipped_inventory_unit = order.inventory_units[1]
-        order.shipping.ship(
-          inventory_units: [@shipped_inventory_unit],
-          stock_location: @shipment.stock_location,
-          address: order.ship_address,
-          shipping_method: @shipment.shipping_method
-        )
-
-        # Create an expedited exchange for the shipped inventory unit.
-        # This generates a new inventory unit attached to the existing line item.
-        Spree::ReturnAuthorization.create!(
-          order: order,
-          stock_location: @shipment.stock_location,
-          reason: create(:return_reason),
-          return_items: [
-            Spree::ReturnItem.new(
-              inventory_unit: @shipped_inventory_unit,
-              exchange_variant: exchange_variant
-            )
-          ]
-        )
-        @exchange_inventory_unit = order.inventory_units.reload[2]
-      end
-
-      context 'when canceling an unshipped inventory unit from the original order' do
-        subject do
-          unit_cancel.compute_amount(@unshipped_inventory_unit.line_item)
-        end
-
-        let(:unit_cancel) do
-          Spree::UnitCancel.create!(
-            inventory_unit: @unshipped_inventory_unit,
-            reason: Spree::UnitCancel::SHORT_SHIP
-          )
-        end
-
-        it { is_expected.to eq(-10.00) }
-      end
-
-      context 'when canceling an unshipped exchange inventory unit' do
-        subject do
-          unit_cancel.compute_amount(@exchange_inventory_unit.line_item)
-        end
-
-        let(:unit_cancel) do
-          Spree::UnitCancel.create!(
-            inventory_unit: @exchange_inventory_unit,
-            reason: Spree::UnitCancel::SHORT_SHIP
-          )
-        end
-
-        it { is_expected.to eq(-10.00) }
-      end
-    end
   end
 end

data/spec/models/spree/user_spec.rb

@@ -92,7 +92,9 @@ describe Spree::LegacyUser, type: :model do
       end
 
       it "has payment sources" do
-        expect(user.payment_sources.first.gateway_customer_profile_id).not_to be_empty
+        Spree::Deprecation.silence do
+          expect(user.payment_sources.first.gateway_customer_profile_id).not_to be_empty
+        end
       end
     end
   end

data/spec/models/spree/variant/vat_price_generator_spec.rb

@@ -30,10 +30,16 @@ describe Spree::Variant::VatPriceGenerator do
     end
 
     it "will not build prices that are already present" do
-      variant.prices.build(amount: 11, country_iso: "FR")
-      variant.prices.build(amount: 11, country_iso: nil)
       expect { subject }.not_to change { variant.prices.length }
     end
+
+    # We need to remove the price for FR from the database so it is created in memory, and then run VatPriceGenerator twice to trigger the duplicate price issue.
+    it "will not build duplicate prices on multiple runs" do
+      variant.prices.where(country_iso: "FR").destroy_all
+      variant.reload
+      described_class.new(variant).run
+      expect { subject }.not_to change { variant.prices.size }
+    end
   end
 
   context "with no default admin country" do

data/spec/models/spree/variant_spec.rb

@@ -66,17 +66,19 @@ describe Spree::Variant, type: :model do
       let!(:high_vat) { create(:tax_rate, included_in_price: true, amount: 0.25, zone: high_vat_zone, tax_category: tax_category) }
       let!(:low_vat) { create(:tax_rate, included_in_price: true, amount: 0.15, zone: low_vat_zone, tax_category: tax_category) }
 
-      let(:product) { create(:product, tax_category: tax_category) }
+      let(:product) { build(:product, tax_category: tax_category) }
 
-      subject(:new_variant) { create(:variant, price: 15, product: product) }
+      subject(:new_variant) { build(:variant, price: 15) }
 
       it "creates the appropriate prices for them" do
-        # default price + FR, DE, DK
-        expect { new_variant }.to change { Spree::Price.count }.by(4)
+        product.variants << new_variant
+        product.save!
         expect(new_variant.prices.find_by(country_iso: "FR").amount).to eq(17.25)
         expect(new_variant.prices.find_by(country_iso: "DE").amount).to eq(18.75)
         expect(new_variant.prices.find_by(country_iso: "DK").amount).to eq(18.75)
         expect(new_variant.prices.find_by(country_iso: nil).amount).to eq(15.00)
+        # default price + FR, DE, DK
+        expect(new_variant.prices.count).to eq(4)
       end
 
       context "when the products price changes" do
@@ -561,6 +563,16 @@ describe Spree::Variant, type: :model do
         end
       end
     end
+
+    describe "cache clearing on update" do
+      it "correctly reports after updating track_inventory" do
+        variant.stock_items.first.set_count_on_hand 0
+        expect(variant).not_to be_in_stock
+
+        variant.update!(track_inventory: false)
+        expect(variant).to be_in_stock
+      end
+    end
   end
 
   describe '#is_backorderable' do