solidus_core 2.2.2 → 2.3.0.beta1

data/spec/models/spree/order_spec.rb

@@ -1,9 +1,17 @@
 require 'spec_helper'
 
 describe Spree::Order, type: :model do
-  let(:store) { build_stubbed(:store) }
-  let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }
-  let(:order) { stub_model(Spree::Order, user: user, store: store) }
+  let(:store) { create(:store) }
+  let(:user) { create(:user, email: "spree@example.com") }
+  let(:order) { create(:order, user: user, store: store) }
+  let(:promotion) do
+    FactoryGirl.create(
+      :promotion,
+      :with_order_adjustment,
+      code: "discount"
+    )
+  end
+  let(:code) { promotion.codes.first }
 
   before do
     allow(Spree::LegacyUser).to receive_messages(current: mock_model(Spree::LegacyUser, id: 123))
@@ -171,12 +179,14 @@ describe Spree::Order, type: :model do
       create(:line_item, order: order)
       create(:shipment, order: order)
       create(:adjustment, adjustable: order, order: order)
+      promotion.activate(order: order, promotion_code: code)
       order.update!
 
       # Make sure we are asserting changes
       expect(order.line_items).not_to be_empty
       expect(order.shipments).not_to be_empty
       expect(order.adjustments).not_to be_empty
+      expect(order.promotions).not_to be_empty
       expect(order.item_total).not_to eq 0
       expect(order.item_count).not_to eq 0
       expect(order.shipment_total).not_to eq 0
@@ -188,6 +198,7 @@ describe Spree::Order, type: :model do
       expect(order.line_items).to be_empty
       expect(order.shipments).to be_empty
       expect(order.adjustments).to be_empty
+      expect(order.promotions).to be_empty
       expect(order.item_total).to eq 0
       expect(order.item_count).to eq 0
       expect(order.shipment_total).to eq 0
@@ -195,6 +206,21 @@ describe Spree::Order, type: :model do
     end
   end
 
+  context '#outstanding_balance' do
+    let(:order) { create(:order_ready_to_ship, line_items_count: 3) }
+    let(:payment) { order.payments.first }
+
+    it "should handle refunds properly" do
+      order.cancellations.short_ship([order.inventory_units.first])
+      expect(order.outstanding_balance).to be_negative
+      expect(order.payment_state).to eq('credit_owed')
+      create(:refund, amount: order.outstanding_balance.abs, payment: payment, transaction_id: nil)
+      order.reload
+      expect(order.outstanding_balance).to eq(0)
+      expect(order.payment_state).to eq('paid')
+    end
+  end
+
   context "#display_outstanding_balance" do
     it "returns the value as a spree money" do
       allow(order).to receive(:outstanding_balance) { 10.55 }
@@ -491,7 +517,9 @@ describe Spree::Order, type: :model do
       order.update_column(:payment_state, 'balance_due')
       order.payment_state = 'paid'
       expect(order.state_changes).to be_empty
-      order.state_changed('payment')
+      Spree::Deprecation.silence do
+        order.state_changed('payment')
+      end
       state_change = order.state_changes.find_by(name: 'payment')
       expect(state_change.previous_state).to eq('balance_due')
       expect(state_change.next_state).to eq('paid')
@@ -500,7 +528,9 @@ describe Spree::Order, type: :model do
     it "does not do anything if state does not change" do
       order.update_column(:payment_state, 'balance_due')
       expect(order.state_changes).to be_empty
-      order.state_changed('payment')
+      Spree::Deprecation.silence do
+        order.state_changed('payment')
+      end
       expect(order.state_changes).to be_empty
     end
   end
@@ -508,7 +538,7 @@ describe Spree::Order, type: :model do
   # Regression test for https://github.com/spree/spree/issues/4199
   context "#available_payment_methods" do
     it "includes frontend payment methods" do
-      payment_method = Spree::PaymentMethod.create!({
+      payment_method = Spree::PaymentMethod::Check.create!({
         name: "Fake",
         active: true,
         available_to_users: true,
@@ -518,7 +548,7 @@ describe Spree::Order, type: :model do
     end
 
     it "includes 'both' payment methods" do
-      payment_method = Spree::PaymentMethod.create!({
+      payment_method = Spree::PaymentMethod::Check.create!({
         name: "Fake",
         active: true,
         available_to_users: true,
@@ -528,7 +558,7 @@ describe Spree::Order, type: :model do
     end
 
     it "does not include a payment method twice" do
-      payment_method = Spree::PaymentMethod.create!({
+      payment_method = Spree::PaymentMethod::Check.create!({
         name: "Fake",
         active: true,
         available_to_users: true,
@@ -539,7 +569,7 @@ describe Spree::Order, type: :model do
     end
 
     it "does not include inactive payment methods" do
-      Spree::PaymentMethod.create!({
+      Spree::PaymentMethod::Check.create!({
         name: "Fake",
         active: false,
         available_to_users: true,
@@ -675,39 +705,52 @@ describe Spree::Order, type: :model do
     end
   end
 
-  context "#generate_order_number" do
-    context "when no configure" do
-      let(:default_length) { Spree::Order::ORDER_NUMBER_LENGTH + Spree::Order::ORDER_NUMBER_PREFIX.length }
-      subject(:order_number) { order.generate_order_number }
+  describe "#generate_order_number" do
+    let(:order) { build(:order) }
+
+    context "with default app configuration" do
+      it 'calls the default order number generator' do
+        expect_any_instance_of(Spree::Order::NumberGenerator).to receive(:generate)
+        order.generate_order_number
+      end
+    end
+
+    context "with order number generator configured" do
+      class TruthNumberGenerator
+        def initialize(options = {}); end
 
-      describe '#class' do
-        subject { super().class }
-        it { is_expected.to eq String }
+        def generate
+          '42'
+        end
       end
 
-      describe '#length' do
-        subject { super().length }
-        it { is_expected.to eq default_length }
+      before do
+        expect(Spree::Config).to receive(:order_number_generator) do
+          TruthNumberGenerator.new
+        end
       end
-      it { is_expected.to match /^#{Spree::Order::ORDER_NUMBER_PREFIX}/ }
-    end
 
-    context "when length option is 5" do
-      let(:option_length) { 5 + Spree::Order::ORDER_NUMBER_PREFIX.length }
-      it "should be option length for order number" do
-        expect(order.generate_order_number(length: 5).length).to eq option_length
+      it 'calls the configured order number generator' do
+        order.generate_order_number
+        expect(order.number).to eq '42'
       end
     end
 
-    context "when letters option is true" do
-      it "generates order number include letter" do
-        expect(order.generate_order_number(length: 100, letters: true)).to match /[A-Z]/
+    context "with number already present" do
+      before do
+        order.number = '123'
+      end
+
+      it 'does not generate new number' do
+        order.generate_order_number
+        expect(order.number).to eq '123'
       end
     end
 
-    context "when prefix option is 'P'" do
-      it "generates order number and it prefix is 'P'" do
-        expect(order.generate_order_number(prefix: 'P')).to match /^P/
+    context "passing options" do
+      it 'is deprecated' do
+        expect(Spree::Deprecation).to receive(:warn)
+        order.generate_order_number(length: 2)
       end
     end
   end
@@ -768,6 +811,88 @@ describe Spree::Order, type: :model do
     end
   end
 
+  context "#assign_default_user_addresses" do
+    let(:order) { Spree::Order.new }
+
+    subject { order.assign_default_user_addresses }
+
+    context "when no user is associated to the order" do
+      it "does not associate any bill address" do
+        expect { subject }.not_to change { order.bill_address }.from(nil)
+      end
+
+      it "does not associate any ship address" do
+        expect { subject }.not_to change { order.ship_address }.from(nil)
+      end
+    end
+
+    context "when user is associated to the order" do
+      let(:user)         { build_stubbed(:user) }
+      let(:bill_address) { nil }
+      let(:ship_address) { nil }
+
+      before do
+        order.associate_user!(user)
+        user.bill_address = bill_address
+        user.ship_address = ship_address
+      end
+
+      context "but has no bill address associated" do
+        it "does not associate any bill address" do
+          expect { subject }.not_to change { order.bill_address }.from(nil)
+        end
+      end
+
+      context "and has an invalid bill address associated " do
+        let(:bill_address) { build(:address, firstname: nil) } # invalid address
+
+        it "does not associate any bill address" do
+          expect { subject }.not_to change { order.bill_address }.from(nil)
+        end
+      end
+
+      context "and has a valid address associated " do
+        let(:bill_address) { build(:address) }
+
+        it "does associate user bill address" do
+          expect { subject }.to change { order.bill_address }.from(nil).to(bill_address)
+        end
+      end
+
+      context "but has no ship address associated" do
+        it "does not associate any ship address" do
+          expect { subject }.not_to change { order.ship_address }.from(nil)
+        end
+      end
+
+      context "and has an invalid ship address associated " do
+        let(:ship_address) { build(:address, firstname: nil) } # invalid address
+
+        it "does not associate any ship address" do
+          expect { subject }.not_to change { order.ship_address }.from(nil)
+        end
+      end
+
+      context "and has a valid ship address associated" do
+        let(:ship_address) { build(:address) }
+
+        it "does associate user ship address" do
+          expect { subject }.to change { order.ship_address }.from(nil).to(ship_address)
+        end
+
+        context 'when checkout step does not include delivery' do
+          before do
+            expect(order).to receive(:checkout_steps) { %w[some step] }
+          end
+
+          it "does not associate any ship address" do
+            expect { subject }.not_to change { order.ship_address }.from(nil)
+          end
+        end
+      end
+    end
+  end
+
   context "#can_ship?" do
     let(:order) { Spree::Order.create }
 
@@ -1409,56 +1534,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, available_to_users: false) }
-
-      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_taxation_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+RSpec.describe Spree::OrderTaxation do
+  let(:shipping_address) { FactoryGirl.create(:address, state: new_york) }
+  let(:order) { FactoryGirl.create(:order, ship_address: shipping_address, state: "delivery") }
+
+  let(:new_york) { FactoryGirl.create(:state, state_code: "NY") }
+  let(:new_york_zone) { FactoryGirl.create(:zone, states: [new_york]) }
+
+  let(:books_category) { FactoryGirl.create(:tax_category, name: "Books") }
+  let(:book_tax_rate) do
+    FactoryGirl.create(
+      :tax_rate,
+      name: "New York Sales Tax",
+      tax_categories: [books_category],
+      zone: new_york_zone,
+      included_in_price: false,
+      amount: 0.05
+    )
+  end
+
+  let(:book) do
+    FactoryGirl.create(
+      :product,
+      price: 20,
+      name: "Book",
+      tax_category: books_category,
+    )
+  end
+
+  let(:taxation) { described_class.new(order) }
+
+  describe "#apply" do
+    let(:line_item) { order.contents.add(book.master) }
+
+    let(:line_item_tax) do
+      Spree::Tax::ItemTax.new(
+        item_id: line_item.id,
+        label: "Tax!",
+        tax_rate: book_tax_rate,
+        amount: 5,
+        included_in_price: false
+      )
+    end
+
+    let(:taxes) do
+      Spree::Tax::OrderTax.new(
+        order_id: order.id,
+        line_item_taxes: [line_item_tax],
+        shipment_taxes: []
+      )
+    end
+
+    before { taxation.apply(taxes) }
+
+    it "creates a new tax adjustment", aggregate_failures: true do
+      expect(line_item.adjustments.count).to eq 1
+
+      tax_adjustment = line_item.adjustments.first
+      expect(tax_adjustment.label).to eq "Tax!"
+      expect(tax_adjustment.source).to eq book_tax_rate
+      expect(tax_adjustment.amount).to eq 5
+      expect(tax_adjustment.included).to be false
+    end
+
+    context "when new taxes are applied" do
+      let(:new_line_item_tax) do
+        Spree::Tax::ItemTax.new(
+          item_id: line_item.id,
+          label: "Tax!",
+          tax_rate: book_tax_rate,
+          amount: 10,
+          included_in_price: false
+        )
+      end
+
+      let(:new_taxes) do
+        Spree::Tax::OrderTax.new(
+          order_id: order.id,
+          line_item_taxes: [new_line_item_tax],
+          shipment_taxes: []
+        )
+      end
+
+      it "updates the existing tax amount", aggregate_failures: true do
+        expect {
+          taxation.apply(new_taxes)
+        }.to change {
+          line_item.adjustments.first.amount
+        }.from(5).to(10)
+      end
+
+      context "and the adjustment is finalized" do
+        before do
+          line_item.adjustments.first.finalize!
+        end
+
+        it "does not update the tax amount", aggregate_failures: true do
+          expect {
+            taxation.apply(new_taxes)
+          }.to change {
+            line_item.adjustments.first.amount
+          }.from(5).to(10)
+        end
+      end
+    end
+
+    context "when taxes are removed" do
+      let(:new_taxes) do
+        Spree::Tax::OrderTax.new(
+          order_id: order.id,
+          line_item_taxes: [],
+          shipment_taxes: []
+        )
+      end
+
+      it "removes the tax adjustment" do
+        expect {
+          taxation.apply(new_taxes)
+        }.to change {
+          line_item.adjustments.count
+        }.from(1).to(0)
+      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

@@ -34,6 +34,17 @@ module Spree
         }.to change { order.shipment_total }.to 10
       end
 
+      context 'with a source-less line item adjustment' do
+        let(:line_item) { create(:line_item, order: order, price: 10) }
+        before do
+          create(:adjustment, source: nil, adjustable: line_item, order: order, amount: -5)
+        end
+
+        it "updates the line item total" do
+          expect { updater.update }.to change { line_item.reload.adjustment_total }.from(0).to(-5)
+        end
+      end
+
       context 'with order promotion followed by line item addition' do
         let(:promotion) { Spree::Promotion.create!(name: "10% off") }
         let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
@@ -273,7 +284,7 @@ module Spree
       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!(:tax_rate) { create(:tax_rate, zone: tax_zone, tax_categories: [tax_category]) }
 
         let(:order) do
           create(
@@ -301,18 +312,20 @@ module Spree
           end
         end
 
-        context 'with a custom tax_adjuster_class' do
-          let(:custom_adjuster_class) { double }
-          let(:custom_adjuster_instance) { double }
+        context 'with a custom tax_calculator_class' do
+          let(:custom_calculator_class) { double }
+          let(:custom_calculator_instance) { double }
 
           before do
             order # generate this first so we can expect it
-            Spree::Config.tax_adjuster_class = custom_adjuster_class
+            Spree::Config.tax_calculator_class = custom_calculator_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)
+            expect(custom_calculator_class).to receive(:new).with(order).at_least(:once).and_return(custom_calculator_instance)
+            expect(custom_calculator_instance).to receive(:calculate).at_least(:once).and_return(
+              Spree::Tax::OrderTax.new(order_id: order.id, line_item_taxes: [], shipment_taxes: [])
+            )
 
             order.update!
           end
@@ -452,20 +465,6 @@ module Spree
       end
     end
 
-    it "state change" do
-      order.shipment_state = 'shipped'
-      state_changes = double
-      allow(order).to receive_messages state_changes: state_changes
-      expect(state_changes).to receive(:create).with(
-        previous_state: nil,
-        next_state: 'shipped',
-        name: 'shipment',
-        user_id: nil
-      )
-
-      order.state_changed('shipment')
-    end
-
     context "completed order" do
       before { allow(order).to receive_messages completed?: true }
 

data/spec/models/spree/payment_create_spec.rb

@@ -154,12 +154,20 @@ module Spree
       context "unpermitted" do
         let(:attributes) { ActionController::Parameters.new(valid_attributes) }
 
-        it "ignores all attributes" do
-          expect(new_payment).to have_attributes(
-            amount: 0,
-            payment_method: nil,
-            source: nil
-          )
+        if Rails.gem_version < Gem::Version.new('5.1')
+          it "ignores all attributes" do
+            expect(new_payment).to have_attributes(
+              amount: 0,
+              payment_method: nil,
+              source: nil
+            )
+          end
+        else
+          it "raises an exception" do
+            expect {
+              new_payment
+            }.to raise_exception(ActionController::UnfilteredParameters)
+          end
         end
       end
 

data/spec/models/spree/payment_method/bogus_credit_card_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Spree
+  describe PaymentMethod::BogusCreditCard, type: :model do
+    let(:bogus) { create(:credit_card_payment_method) }
+    let!(:cc) { create(:credit_card, payment_method: bogus, gateway_customer_profile_id: "BGS-RERTERT") }
+  end
+end

data/spec/models/spree/payment_method/check_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Spree::PaymentMethod::Check do
+  let(:order) { create(:order) }
+  subject { described_class.new }
+
+  context "#can_capture?" do
+    let(:payment) { create(:payment, order: order, state: state) }
+
+    context "with payment in state checkout" do
+      let(:state) { "checkout" }
+
+      it "returns true" do
+        expect(subject.can_capture?(payment)).to be_truthy
+      end
+    end
+
+    context "with payment in state pending" do
+      let(:state) { "pending" }
+
+      it "returns true" do
+        expect(subject.can_capture?(payment)).to be_truthy
+      end
+    end
+
+    context "with payment in state failed" do
+      let(:state) { "failed" }
+
+      it "returns false" do
+        expect(subject.can_capture?(payment)).to be_falsy
+      end
+    end
+  end
+
+  context "#can_void?" do
+    let(:payment) { create(:payment, order: order, state: state) }
+
+    context "with payment in state checkout" do
+      let(:state) { "checkout" }
+
+      it "returns true" do
+        expect(subject.can_void?(payment)).to be_truthy
+      end
+    end
+
+    context "with payment in state void" do
+      let(:state) { "void" }
+
+      it "returns false" do
+        expect(subject.can_void?(payment)).to be_falsy
+      end
+    end
+  end
+
+  context "#capture" do
+    it "succeds" do
+      expect(subject.capture).to be_success
+    end
+  end
+
+  context "#cancel" do
+    it "returns nil" do
+      expect(subject.cancel).to be_nil
+    end
+  end
+
+  context "#void" do
+    it "succeds" do
+      expect(subject.void).to be_success
+    end
+  end
+
+  context "#credit" do
+    it "succeds" do
+      expect(subject.credit).to be_success
+    end
+  end
+end