solidus_core 2.0.3 → 2.1.0.beta1

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

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
 describe Spree::Order, type: :model do
-  let(:order) { stub_model(Spree::Order) }
+  let(:order) { create(:order) }
 
   context "#update!" do
-    let(:line_items) { [mock_model(Spree::LineItem, amount: 5)] }
-
     context "when there are update hooks" do
       before { Spree::Order.register_update_hook :foo }
       after { Spree::Order.update_hooks.clear }

data/spec/models/spree/order_cancellations_spec.rb

@@ -134,17 +134,19 @@ describe Spree::OrderCancellations do
       let(:line_item) { order.line_items.to_a.first }
       let(:inventory_unit_1) { line_item.inventory_units[0] }
       let(:inventory_unit_2) { line_item.inventory_units[1] }
+      let(:promotion) { create(:promotion, :with_line_item_adjustment) }
+      let(:promotion_action) { promotion.actions[0] }
 
       before do
         order.contents.add(line_item.variant)
 
         # make the total $1.67 so it divides unevenly
         line_item.adjustments.create!(
-          source_type: 'Spree::TaxRate',
           order: order,
           amount: 0.01,
-          label: 'some fake tax',
-          finalized: true
+          label: 'some promo',
+          source: promotion_action,
+          finalized: true,
         )
         order.update!
       end
@@ -154,7 +156,7 @@ describe Spree::OrderCancellations do
         order.cancellations.short_ship([inventory_unit_2])
         expect(line_item.adjustments.map(&:amount)).to match_array(
           [
-            0.01, # tax adjustment
+            0.01,  # promo adjustment
             -0.84, # short ship 1
             -0.83, # short ship 2
           ]

data/spec/models/spree/order_contents_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Spree::OrderContents, type: :model do
   let!(:store) { create :store }
-  let(:order) { Spree::Order.create }
+  let(:order) { create(:order) }
   let(:variant) { create(:variant) }
   let!(:stock_location) { variant.stock_locations.first }
   let(:stock_location_2) { create(:stock_location) }
 
-  subject { described_class.new(order) }
+  subject(:order_contents) { described_class.new(order) }
 
   context "#add" do
     context 'given quantity is not explicitly provided' do
@@ -96,6 +96,38 @@ describe Spree::OrderContents, type: :model do
         include_context "discount changes order total"
       end
     end
+
+    describe 'tax calculations' do
+      let!(:zone) { create(:global_zone) }
+      let!(:tax_rate) do
+        create(:tax_rate, zone: zone, tax_category: variant.tax_category)
+      end
+
+      context 'when the order has a taxable address' do
+        before do
+          expect(order.tax_address.country_id).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 the order does not have a taxable address' do
+        before do
+          order.update_attributes!(ship_address: nil, bill_address: nil)
+          expect(order.tax_address.country_id).to be_nil
+        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(0)
+        end
+      end
+    end
   end
 
   context "#remove" do
@@ -224,54 +256,6 @@ describe Spree::OrderContents, type: :model do
       }.to change { subject.order.total }
     end
 
-    context "given an order with existing addresses" do
-      let(:default_address) { create :address, state_code: "NY", zipcode: "17402" }
-      let(:order_with_address ) { create :order, ship_address: default_address, bill_address: default_address }
-
-      subject { described_class.new(order_with_address) }
-
-      context "when an address in a potentially different tax zone is supplied " do
-        let(:updated_address) { build :address, state_code: "AL",  zipcode: "64092" }
-
-        let(:params) do
-          { ship_address_attributes: updated_address.value_attributes, bill_address_attributes: updated_address.value_attributes }
-        end
-
-        it "updates tax adjustments" do
-          expect(subject.order).to receive(:create_tax_charge!)
-          subject.update_cart params
-        end
-      end
-
-      context "when an address in potentially the same tax zone is supplied" do
-        let(:updated_address) { build :address, state_code: "NY", zipcode: "17402", firstname: 'Robert' }
-
-        let(:params) do
-          { ship_address_attributes: updated_address.value_attributes, bill_address_attributes: updated_address.value_attributes }
-        end
-
-        it "does not updates tax adjustments" do
-          expect(subject.order).not_to receive(:create_tax_charge!)
-          subject.update_cart params
-        end
-      end
-    end
-
-    context "given an order with no existing addresses" do
-      context "when an address is supplied" do
-        let(:updated_address) { build :address, state_code: "CA", zipcode: "14902" }
-
-        let(:params) do
-          { ship_address_attributes: updated_address.attributes, bill_address_attributes: updated_address.value_attributes }
-        end
-
-        it "does not updates tax adjustments" do
-          expect(subject.order).not_to receive(:create_tax_charge!)
-          subject.update_cart params
-        end
-      end
-    end
-
     context "submits item quantity 0" do
       let(:params) do
         { line_items_attributes: {

data/spec/models/spree/order_inventory_spec.rb

@@ -201,12 +201,10 @@ describe Spree::OrderInventory, type: :model do
       end
 
       it 'should destroy self if not inventory units remain' do
-        shipment.inventory_units[1...999].each(&:destroy)
-        shipment.inventory_units.reload
+        allow(shipment.inventory_units).to receive_messages(count: 0)
+        expect(shipment).to receive(:destroy)
 
-        expect {
-          expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
-        }.to change{ order.shipments.count }.from(1).to(0)
+        expect(subject.send(:remove_from_shipment, shipment, 1)).to eq(1)
       end
 
       context "inventory unit line item and variant points to different products" do

data/spec/models/spree/order_merger_spec.rb

@@ -43,6 +43,26 @@ module Spree
       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)

data/spec/models/spree/order_spec.rb

@@ -1,11 +1,5 @@
 require 'spec_helper'
 
-class FakeCalculator < Spree::Calculator
-  def compute(_computable)
-    5
-  end
-end
-
 describe Spree::Order, type: :model do
   let(:store) { build_stubbed(:store) }
   let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }
@@ -516,7 +510,8 @@ describe Spree::Order, type: :model do
       payment_method = Spree::PaymentMethod.create!({
         name: "Fake",
         active: true,
-        display_on: "front_end"
+        available_to_users: true,
+        available_to_admin: false
       })
       expect(order.available_payment_methods).to include(payment_method)
     end
@@ -525,16 +520,18 @@ describe Spree::Order, type: :model do
       payment_method = Spree::PaymentMethod.create!({
         name: "Fake",
         active: true,
-        display_on: "both"
+        available_to_users: true,
+        available_to_admin: true
       })
       expect(order.available_payment_methods).to include(payment_method)
     end
 
-    it "does not include a payment method twice if display_on is blank" do
+    it "does not include a payment method twice" do
       payment_method = Spree::PaymentMethod.create!({
         name: "Fake",
         active: true,
-        display_on: "both"
+        available_to_users: true,
+        available_to_admin: true
       })
       expect(order.available_payment_methods.count).to eq(1)
       expect(order.available_payment_methods).to include(payment_method)
@@ -543,8 +540,10 @@ describe Spree::Order, type: :model do
     context "with more than one payment method" do
       subject { order.available_payment_methods }
 
-      let!(:first_method) { FactoryGirl.create(:payment_method, display_on: :both) }
-      let!(:second_method) { FactoryGirl.create(:payment_method, display_on: :both) }
+      let!(:first_method) { FactoryGirl.create(:payment_method, available_to_users: true,
+                                               available_to_admin: true) }
+      let!(:second_method) { FactoryGirl.create(:payment_method, available_to_users: true,
+                                               available_to_admin: true) }
 
       before do
         second_method.move_to_top
@@ -575,6 +574,23 @@ describe Spree::Order, type: :model do
             [payment_method_with_store]
           )
         end
+
+        context 'and the store has an extra payment method unavailable to users' do
+          let!(:admin_only_payment_method) do create(:payment_method,
+                                                     available_to_users: false,
+                                                     available_to_admin: true)
+          end
+
+          before do
+            store_with_payment_methods.payment_methods << admin_only_payment_method
+          end
+
+          it 'returns only the payment methods available to users for that store' do
+            expect(order.available_payment_methods).to match_array(
+              [payment_method_with_store]
+            )
+          end
+        end
       end
 
       context 'when the store does not have payment methods' do
@@ -1488,56 +1504,4 @@ describe Spree::Order, type: :model do
       end
     end
   end
-
-  describe "#validate_payments_attributes" do
-    let(:attributes) { [ActionController::Parameters.new(payment_method_id: payment_method.id)] }
-    subject do
-      order.validate_payments_attributes(attributes)
-    end
-
-    context "with empty array" do
-      let(:attributes) { [] }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with no payment method specified" do
-      let(:attributes) { [ActionController::Parameters.new({})] }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with valid payment method" do
-      let(:payment_method) { create(:check_payment_method) }
-      it "doesn't error" do
-        subject
-      end
-    end
-
-    context "with inactive payment method" do
-      let(:payment_method) { create(:check_payment_method, active: false) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with unavailable payment method" do
-      let(:payment_method) { create(:check_payment_method, display_on: "back_end") }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with soft-deleted payment method" do
-      let(:payment_method) { create(:check_payment_method, deleted_at: Time.current) }
-
-      it "raises RecordNotFound" do
-        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
 end

data/spec/models/spree/order_update_attributes_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Spree
   RSpec.describe OrderUpdateAttributes do
     let(:order) { create(:order) }
-    let(:payment_method) { create(:payment_method) }
     let(:request_env) { nil }
     let(:update) { described_class.new(order, attributes, request_env: request_env) }
 
@@ -26,10 +25,7 @@ module Spree
       let(:attributes) do
         {
           payments_attributes: [
-            {
-              payment_method_id: payment_method.id,
-              source_attributes: attributes_for(:credit_card)
-            }
+            { source_attributes: attributes_for(:credit_card) }
           ]
         }
       end

data/spec/models/spree/order_updater_spec.rb

@@ -67,6 +67,257 @@ module Spree
       end
     end
 
+    describe '#recalculate_adjustments ' do
+      describe 'promotion recalculation' do
+        let(:order) { create(:order_with_line_items, line_items_count: 1, line_items_price: 10) }
+        let(:line_item) { order.line_items[0] }
+
+        context 'when the item quantity has changed' do
+          let(:promotion) { create(:promotion, promotion_actions: [promotion_action]) }
+          let(:promotion_action) { Spree::Promotion::Actions::CreateItemAdjustments.new(calculator: calculator) }
+          let(:calculator) { Spree::Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
+
+          before do
+            promotion.activate(order: order)
+            order.update!
+            line_item.update!(quantity: 2)
+          end
+
+          it 'updates the promotion amount' do
+            expect {
+              order.update!
+            }.to change {
+              line_item.promo_total
+            }.from(-1).to(-2)
+          end
+        end
+
+        context 'promotion chooser customization' do
+          before do
+            class Spree::TestPromotionChooser
+              def initialize(_adjustments)
+                raise 'Custom promotion chooser'
+              end
+            end
+
+            Spree::Config.promotion_chooser_class = Spree::TestPromotionChooser
+          end
+
+          it 'uses the defined promotion chooser' do
+            expect { order.update! }.to raise_error('Custom promotion chooser')
+          end
+        end
+
+        context 'default promotion chooser (best promotion is always applied)' do
+          let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
+
+          let(:source) do
+            Promotion::Actions::CreateItemAdjustments.create!(
+              calculator: calculator,
+              promotion: promotion,
+            )
+          end
+          let(:promotion) { create(:promotion) }
+
+          def create_adjustment(label, amount)
+            create(
+              :adjustment,
+              order: order,
+              adjustable: line_item,
+              source: source,
+              amount: amount,
+              finalized: true,
+              label: label,
+            )
+          end
+
+          it 'should make all but the most valuable promotion adjustment ineligible, leaving non promotion adjustments alone' do
+            create_adjustment('Promotion A', -100)
+            create_adjustment('Promotion B', -200)
+            create_adjustment('Promotion C', -300)
+            create(:adjustment, order: order,
+                                adjustable: line_item,
+                                source: nil,
+                                amount: -500,
+                                finalized: true,
+                                label: 'Some other credit')
+            line_item.adjustments.each { |a| a.update_column(:eligible, true) }
+
+            order.update!
+
+            expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+            expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion C')
+          end
+
+          it 'should choose the most recent promotion adjustment when amounts are equal' do
+            # Using Timecop is a regression test
+            Timecop.freeze do
+              create_adjustment('Promotion A', -200)
+              create_adjustment('Promotion B', -200)
+            end
+            line_item.adjustments.each { |a| a.update_column(:eligible, true) }
+
+            order.update!
+
+            expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+            expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
+          end
+
+          it 'should choose the most recent promotion adjustment when amounts are equal' do
+            # Using Timecop is a regression test
+            Timecop.freeze do
+              create_adjustment('Promotion A', -200)
+              create_adjustment('Promotion B', -200)
+            end
+            line_item.adjustments.each { |a| a.update_column(:eligible, true) }
+
+            order.update!
+
+            expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+            expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
+          end
+
+          context 'when previously ineligible promotions become available' do
+            let(:order_promo1) { create(:promotion, :with_order_adjustment, :with_item_total_rule, weighted_order_adjustment_amount: 5, item_total_threshold_amount: 10) }
+            let(:order_promo2) { create(:promotion, :with_order_adjustment, :with_item_total_rule, weighted_order_adjustment_amount: 10, item_total_threshold_amount: 20) }
+            let(:order_promos) { [order_promo1, order_promo2] }
+            let(:line_item_promo1) { create(:promotion, :with_line_item_adjustment, :with_item_total_rule, adjustment_rate: 2.5, item_total_threshold_amount: 10, apply_automatically: true) }
+            let(:line_item_promo2) { create(:promotion, :with_line_item_adjustment, :with_item_total_rule, adjustment_rate: 5, item_total_threshold_amount: 20, apply_automatically: true) }
+            let(:line_item_promos) { [line_item_promo1, line_item_promo2] }
+            let(:order) { create(:order_with_line_items, line_items_count: 1) }
+
+            # Apply promotions in different sequences. Results should be the same.
+            promo_sequences = [
+              [0, 1],
+              [1, 0],
+            ]
+
+            promo_sequences.each do |promo_sequence|
+              context "with promo sequence #{promo_sequence}" do
+                it 'should pick the best order-level promo according to current eligibility' do
+                  # apply both promos to the order, even though only promo1 is eligible
+                  order_promos[promo_sequence[0]].activate order: order
+                  order_promos[promo_sequence[1]].activate order: order
+
+                  order.update!
+                  order.reload
+                  expect(order.all_adjustments.count).to eq(2), 'Expected two adjustments'
+                  expect(order.all_adjustments.eligible.count).to eq(1), 'Expected one elegible adjustment'
+                  expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo1), 'Expected promo1 to be used'
+
+                  order.contents.add create(:variant, price: 10), 1
+                  order.save
+
+                  order.reload
+                  expect(order.all_adjustments.count).to eq(2), 'Expected two adjustments'
+                  expect(order.all_adjustments.eligible.count).to eq(1), 'Expected one elegible adjustment'
+                  expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo2), 'Expected promo2 to be used'
+                end
+
+                it 'should pick the best line-item-level promo according to current eligibility' do
+                  # apply both promos to the order, even though only promo1 is eligible
+                  line_item_promos[promo_sequence[0]].activate order: order
+                  line_item_promos[promo_sequence[1]].activate order: order
+
+                  order.reload
+                  expect(order.all_adjustments.count).to eq(1), 'Expected one adjustment'
+                  expect(order.all_adjustments.eligible.count).to eq(1), 'Expected one elegible adjustment'
+                  # line_item_promo1 is the only one that has thus far met the order total threshold, it is the only promo which should be applied.
+                  expect(order.all_adjustments.first.source.promotion).to eq(line_item_promo1), 'Expected line_item_promo1 to be used'
+
+                  order.contents.add create(:variant, price: 10), 1
+                  order.save
+
+                  order.reload
+                  expect(order.all_adjustments.count).to eq(4), 'Expected four adjustments'
+                  expect(order.all_adjustments.eligible.count).to eq(2), 'Expected two elegible adjustments'
+                  order.all_adjustments.eligible.each do |adjustment|
+                    expect(adjustment.source.promotion).to eq(line_item_promo2), 'Expected line_item_promo2 to be used'
+                  end
+                end
+              end
+            end
+          end
+
+          context 'multiple adjustments and the best one is not eligible' do
+            let!(:promo_a) { create_adjustment('Promotion A', -100) }
+            let!(:promo_c) { create_adjustment('Promotion C', -300) }
+
+            before do
+              promo_a.update_column(:eligible, true)
+              promo_c.update_column(:eligible, false)
+            end
+
+            # regression for https://github.com/spree/spree/issues/3274
+            it 'still makes the previous best eligible adjustment valid' do
+              order.update!
+              expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion A')
+            end
+          end
+
+          it 'should only leave one adjustment even if 2 have the same amount' do
+            create_adjustment('Promotion A', -100)
+            create_adjustment('Promotion B', -200)
+            create_adjustment('Promotion C', -200)
+
+            order.update!
+
+            expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+            expect(line_item.adjustments.promotion.eligible.first.amount.to_i).to eq(-200)
+          end
+        end
+      end
+
+      describe 'tax recalculation' do
+        let!(:ship_address) { create(:address) }
+        let!(:tax_zone) { create(:global_zone) } # will include the above address
+        let!(:tax_rate) { create(:tax_rate, zone: tax_zone, tax_category: tax_category) }
+
+        let(:order) do
+          create(
+            :order_with_line_items,
+            line_items_attributes: [{ price: 10, variant: variant }],
+            ship_address: ship_address,
+          )
+        end
+        let(:line_item) { order.line_items[0] }
+
+        let(:variant) { create(:variant, tax_category: tax_category) }
+        let(:tax_category) { create(:tax_category) }
+
+        context 'when the item quantity has changed' do
+          before do
+            line_item.update!(quantity: 2)
+          end
+
+          it 'updates the promotion amount' do
+            expect {
+              order.update!
+            }.to change {
+              line_item.additional_tax_total
+            }.from(1).to(2)
+          end
+        end
+
+        context 'with a custom tax_adjuster_class' do
+          let(:custom_adjuster_class) { double }
+          let(:custom_adjuster_instance) { double }
+
+          before do
+            order # generate this first so we can expect it
+            Spree::Config.tax_adjuster_class = custom_adjuster_class
+          end
+
+          it 'uses the configured class' do
+            expect(custom_adjuster_class).to receive(:new).with(order).at_least(:once).and_return(custom_adjuster_instance)
+            expect(custom_adjuster_instance).to receive(:adjust!).at_least(:once)
+
+            order.update!
+          end
+        end
+      end
+    end
+
     context "updating shipment state" do
       before do
         allow(order).to receive_messages backordered?: false