solidus_core 2.1.1 → 2.2.0.beta1

data/spec/jobs/promotion_code_batch_job_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+describe Spree::PromotionCodeBatchJob, type: :job do
+  let(:email) { "test@email.com" }
+  let(:promotion_code_batch) do
+    Spree::PromotionCodeBatch.create!(
+      promotion_id: create(:promotion).id,
+      base_code: "test",
+      number_of_codes: 10,
+      email: email
+    )
+  end
+
+  context "with a successful build" do
+    before do
+      allow(Spree::PromotionCodeBatchMailer)
+        .to receive(:promotion_code_batch_finished)
+        .and_call_original
+    end
+    context "with an email address" do
+      it "sends an email" do
+        subject.perform(promotion_code_batch)
+        expect(Spree::PromotionCodeBatchMailer)
+          .to have_received(:promotion_code_batch_finished)
+      end
+    end
+    context "with no email address" do
+      let(:email) { nil }
+      it "sends an email" do
+        subject.perform(promotion_code_batch)
+        expect(Spree::PromotionCodeBatchMailer)
+          .to_not have_received(:promotion_code_batch_finished)
+      end
+    end
+  end
+
+  context "with a failed build" do
+    before do
+      allow_any_instance_of(Spree::PromotionCode::BatchBuilder)
+        .to receive(:build_promotion_codes)
+        .and_raise("Error")
+
+      allow(Spree::PromotionCodeBatchMailer)
+        .to receive(:promotion_code_batch_errored)
+        .and_call_original
+
+      expect { subject.perform(promotion_code_batch) }
+        .to raise_error RuntimeError
+    end
+
+    context "with an email address" do
+      it "sends an email" do
+        expect(Spree::PromotionCodeBatchMailer)
+          .to have_received(:promotion_code_batch_errored)
+      end
+    end
+
+    context "with no email address" do
+      let(:email) { nil }
+      it "sends an email" do
+        expect(Spree::PromotionCodeBatchMailer)
+          .to_not have_received(:promotion_code_batch_errored)
+      end
+    end
+  end
+end

data/spec/lib/calculated_adjustments_spec.rb

@@ -1,7 +1,111 @@
 require 'spec_helper'
 
 describe Spree::CalculatedAdjustments do
+  let(:calculator_class) { Spree::Calculator::FlatRate }
+
+  with_model :Calculable, scope: :all do
+    model do
+      include Spree::CalculatedAdjustments
+    end
+  end
+
   it "should add has_one :calculator relationship" do
-    assert Spree::ShippingMethod.reflect_on_all_associations(:has_one).map(&:name).include?(:calculator)
+    expect(Calculable.reflect_on_all_associations(:has_one).map(&:name)).to include(:calculator)
+  end
+
+  describe 'initialization' do
+    context 'with no calculator' do
+      subject { Calculable.new }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be nil
+      end
+
+      it 'is not valid' do
+        expect(subject).not_to be_valid
+        expect(subject.errors[:calculator]).to eq ["can't be blank"]
+      end
+    end
+
+    context 'with calculator object' do
+      subject { Calculable.new(calculator: calculator_class.new) }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 0 # not yet saved
+      end
+
+      it 'can be created' do
+        subject.save!
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 1 # saved in database
+      end
+    end
+
+    context 'with calculator_type' do
+      subject { Calculable.new(calculator_type: calculator_class.to_s) }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 0 # not yet saved
+      end
+
+      it 'can be created' do
+        subject.save!
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(calculator_class.count).to eq 1 # saved in database
+      end
+    end
+
+    context 'with calculator_type and calculator_attributes' do
+      subject { Calculable.new(calculator_type: calculator_class.to_s, calculator_attributes: {preferred_amount: 123}) }
+
+      it 'can be initialized' do
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(subject.calculator.preferred_amount).to eq 123
+        expect(calculator_class.count).to eq 0 # not yet saved
+      end
+
+      it 'can be created' do
+        subject.save!
+        expect(subject.calculator).to be_a(calculator_class)
+        expect(subject.calculator.preferred_amount).to eq 123
+        expect(calculator_class.count).to eq 1 # saved in database
+      end
+    end
+  end
+
+  describe 'update' do
+    subject { Calculable.create!(calculator_type: calculator_class.to_s) }
+
+    it "can update calculator attributes with id" do
+      subject.update!(calculator_attributes: {
+        id: subject.calculator.id,
+        preferred_amount: 123
+      })
+      expect(subject.calculator.preferred_amount).to eq(123)
+      subject.reload
+      expect(subject.calculator.preferred_amount).to eq(123)
+    end
+
+    it "can update calculator attributes without id" do
+      subject.update!(calculator_attributes: {
+        preferred_amount: 123
+      })
+      expect(subject.calculator.preferred_amount).to eq(123)
+      subject.reload
+      expect(subject.calculator.preferred_amount).to eq(123)
+    end
+
+    it "can update both calculator type and attributes" do
+      subject.update!(calculator_type: 'Spree::Calculator::FlexiRate', calculator_attributes: {
+        preferred_first_item: 123
+      })
+      expect(subject.calculator.class).to eq(Spree::Calculator::FlexiRate)
+      expect(subject.calculator.preferred_first_item).to eq(123)
+      subject.reload
+      expect(subject.calculator.class).to eq(Spree::Calculator::FlexiRate)
+      expect(subject.calculator.preferred_first_item).to eq(123)
+    end
   end
 end

data/spec/lib/spree/core/testing_support/factories/order_factory_spec.rb

@@ -122,6 +122,8 @@ RSpec.describe 'order factory' do
           total: 110,
           state: 'complete'
         )
+        expect(order.inventory_units.where(pending: true)).to be_empty
+        expect(order.inventory_units.where(pending: false)).to_not be_empty
       end
     end
   end
@@ -201,7 +203,8 @@ RSpec.describe 'order factory' do
         expect(order).to have_attributes(
           total: 110,
           payment_total: 110,
-          payment_state: "paid"
+          payment_state: "paid",
+          shipment_state: "shipped"
         )
 
         expect(order.payments.count).to eq 1

data/spec/lib/spree/core/testing_support/factories/payment_factory_spec.rb

@@ -14,6 +14,14 @@ RSpec.describe 'payment factory' do
       expect(payment.source.user).to be_present
       expect(payment.source.user).to eq payment.order.user
     end
+
+    it 'uses the orders bill address for the credit card' do
+      address = create(:address)
+      order = create(:order, bill_address: address)
+      payment = create(factory, order: order)
+
+      expect(payment.source.address).to eq address
+    end
   end
 
   describe 'check payment' do

data/spec/lib/spree/money_spec.rb

@@ -268,4 +268,36 @@ describe Spree::Money do
       end
     end
   end
+
+  it "includes Comparable" do
+    expect(described_class).to include(Comparable)
+  end
+
+  describe "<=>" do
+    let(:usd_10) { Spree::Money.new(10, currency: "USD") }
+    let(:usd_20) { Spree::Money.new(20, currency: "USD") }
+    let(:usd_30) { Spree::Money.new(30, currency: "USD") }
+
+    it "compares the two amounts" do
+      expect(usd_20 <=> usd_20).to eq 0
+      expect(usd_20 <=> usd_10).to be > 0
+      expect(usd_20 <=> usd_30).to be < 0
+    end
+
+    context "with a non Spree::Money object" do
+      it "raises an error" do
+        expect { usd_10 <=> 20 }.to raise_error(TypeError)
+      end
+    end
+
+    context "with differing currencies" do
+      let(:cad) { Spree::Money.new(10, currency: "CAD") }
+
+      it "raises an error" do
+        expect { usd_10 <=> cad }.to raise_error(
+          Spree::Money::DifferentCurrencyError
+        )
+      end
+    end
+  end
 end

data/spec/lib/spree/permission_sets/default_customer_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Spree::PermissionSets::DefaultCustomer do
+  context 'as Guest User' do
+    context 'for Order' do
+      context 'guest_token is empty string' do
+        let(:ability) { Spree::Ability.new(nil) }
+        let(:resource) { build(:order) }
+        let(:token) { '' }
+
+        it 'should not be allowed to read or update the order' do
+          allow(resource).to receive_messages(guest_token: '')
+
+          expect(ability).to_not be_able_to(:read, resource, token)
+          expect(ability).to_not be_able_to(:update, resource, token)
+        end
+      end
+    end
+  end
+end

data/spec/mailers/promotion_code_batch_mailer_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+describe Spree::PromotionCodeBatchMailer, type: :mailer do
+  let(:promotion) { create(:promotion, name: "Promotion Test") }
+  let(:promotion_code_batch) do
+    Spree::PromotionCodeBatch.create!(
+      promotion_id: promotion.id,
+      base_code: "test",
+      number_of_codes: 10,
+      email: "test@email.com"
+    )
+  end
+
+  describe "#promotion_code_batch_finished" do
+    subject { described_class.promotion_code_batch_finished(promotion_code_batch) }
+
+    it "sends the email to the email attached to the promotion code batch " do
+      expect(subject.to).to eq([promotion_code_batch.email])
+    end
+
+    it "contains the number of codes created" do
+      expect(subject.body).to include("All 10 codes have been created")
+    end
+
+    it "contains the name of the promotion" do
+      expect(subject.body).to include(promotion.name)
+    end
+  end
+
+  describe "#promotion_code_batch_errored" do
+    before { promotion_code_batch.update(error: "Test error") }
+    subject { described_class.promotion_code_batch_errored(promotion_code_batch) }
+
+    it "sends the email to the email attached to the promotion code batch " do
+      expect(subject.to).to eq([promotion_code_batch.email])
+    end
+
+    it "contains the error" do
+      expect(subject.body).to include("Test error")
+    end
+
+    it "contains the name of the promotion" do
+      expect(subject.body).to include(promotion.name)
+    end
+  end
+end

data/spec/models/spree/credit_card_spec.rb

@@ -16,6 +16,8 @@ describe Spree::CreditCard, type: :model do
 
   let(:credit_card) { Spree::CreditCard.new }
 
+  it_behaves_like 'a payment source'
+
   before(:each) do
     @order = create(:order)
     @payment = Spree::Payment.create(amount: 100, order: @order)
@@ -35,37 +37,6 @@ describe Spree::CreditCard, type: :model do
     allow(@payment).to receive_messages payment_method: @payment_gateway
   end
 
-  describe "#can_capture?" do
-    it "should be true if payment is pending" do
-      payment = mock_model(Spree::Payment, pending?: true, created_at: Time.current)
-      expect(credit_card.can_capture?(payment)).to be true
-    end
-
-    it "should be true if payment is checkout" do
-      payment = mock_model(Spree::Payment, pending?: false, checkout?: true, created_at: Time.current)
-      expect(credit_card.can_capture?(payment)).to be true
-    end
-  end
-
-  describe "#can_void?" do
-    it "should be true if payment is not void" do
-      payment = mock_model(Spree::Payment, failed?: false, void?: false)
-      expect(credit_card.can_void?(payment)).to be true
-    end
-  end
-
-  describe "#can_credit?" do
-    it "should be false if payment is not completed" do
-      payment = mock_model(Spree::Payment, completed?: false)
-      expect(credit_card.can_credit?(payment)).to be false
-    end
-
-    it "should be false when credit_allowed is zero" do
-      payment = mock_model(Spree::Payment, completed?: true, credit_allowed: 0, order: mock_model(Spree::Order, payment_state: 'credit_owed'))
-      expect(credit_card.can_credit?(payment)).to be false
-    end
-  end
-
   describe "#valid?" do
     it "should validate presence of number" do
       credit_card.attributes = valid_credit_card_attributes.except(:number)
@@ -283,32 +254,6 @@ describe Spree::CreditCard, type: :model do
     end
   end
 
-  describe "#associations" do
-    it "should be able to access its payments" do
-      credit_card.payments.to_a
-    end
-  end
-
-  describe "#first_name" do
-    before do
-      credit_card.name = "Ludwig van Beethoven"
-    end
-
-    it "extracts the first name" do
-      expect(credit_card.first_name).to eq "Ludwig"
-    end
-  end
-
-  describe "#last_name" do
-    before do
-      credit_card.name = "Ludwig van Beethoven"
-    end
-
-    it "extracts the last name" do
-      expect(credit_card.last_name).to eq "van Beethoven"
-    end
-  end
-
   describe "#to_active_merchant" do
     before do
       credit_card.number = "4111111111111111"
@@ -329,44 +274,99 @@ describe Spree::CreditCard, type: :model do
     end
   end
 
-  it 'ensures only one credit card per user is default at a time' do
-    user = FactoryGirl.create(:user)
-    first = FactoryGirl.create(:credit_card, user: user, default: true)
-    second = FactoryGirl.create(:credit_card, user: user, default: true)
+  # TODO: Remove these specs once default is removed
+  describe 'default' do
+    def default_with_silence(card)
+      Spree::Deprecation.silence { card.default }
+    end
 
-    expect(first.reload.default).to eq false
-    expect(second.reload.default).to eq true
+    context 'with a user' do
+      let(:user) { create(:user) }
+      let(:credit_card) { create(:credit_card, user: user) }
 
-    first.default = true
-    first.save!
+      it 'uses the wallet information' do
+        wallet_payment_source = user.wallet.add(credit_card)
+        user.wallet.default_wallet_payment_source = wallet_payment_source
 
-    expect(first.reload.default).to eq true
-    expect(second.reload.default).to eq false
-  end
+        expect(default_with_silence(credit_card)).to be_truthy
+      end
+    end
 
-  it 'allows default credit cards for different users' do
-    first = FactoryGirl.create(:credit_card, user: FactoryGirl.create(:user), default: true)
-    second = FactoryGirl.create(:credit_card, user: FactoryGirl.create(:user), default: true)
+    context 'without a user' do
+      let(:credit_card) { create(:credit_card) }
 
-    expect(first.reload.default).to eq true
-    expect(second.reload.default).to eq true
+      it 'returns false' do
+        expect(default_with_silence(credit_card)).to eq(false)
+      end
+    end
   end
 
-  it 'allows this card to save even if the previously default card has expired' do
-    user = FactoryGirl.create(:user)
-    first = FactoryGirl.create(:credit_card, user: user, default: true)
-    second = FactoryGirl.create(:credit_card, user: user, default: false)
-    first.update_columns(year: DateTime.current.year, month: 1.month.ago.month)
+  # TODO: Remove these specs once default= is removed
+  describe 'default=' do
+    def default_with_silence(card)
+      Spree::Deprecation.silence { card.default }
+    end
 
-    second.update_attributes!(default: true)
-  end
+    context 'with a user' do
+      let(:user) { create(:user) }
+      let(:credit_card) { create(:credit_card, user: user) }
+
+      it 'updates the wallet information' do
+        Spree::Deprecation.silence do
+          credit_card.default = true
+        end
+        expect(user.wallet.default_wallet_payment_source.payment_source).to eq(credit_card)
+      end
+    end
 
-  it 'allows this card to save even if the previously default card has expired' do
-    user = FactoryGirl.create(:user)
-    first = FactoryGirl.create(:credit_card, user: user, default: true)
-    second = FactoryGirl.create(:credit_card, user: user, default: false)
-    first.update_columns(year: DateTime.current.year, month: 1.month.ago.month)
+    context 'with multiple cards for one user' do
+      let(:user) { create(:user) }
+      let(:first_card) { create(:credit_card, user: user) }
+      let(:second_card) { create(:credit_card, user: user) }
 
-    second.update_attributes!(default: true)
+      it 'ensures only one default' do
+        Spree::Deprecation.silence do
+          first_card.default = true
+          second_card.default = true
+        end
+
+        expect(default_with_silence(first_card)).to be_falsey
+        expect(default_with_silence(second_card)).to be_truthy
+
+        Spree::Deprecation.silence do
+          first_card.default = true
+        end
+
+        expect(default_with_silence(first_card)).to be_truthy
+        expect(default_with_silence(second_card)).to be_falsey
+      end
+    end
+
+    context 'with multiple cards for different users' do
+      let(:first_card) { create(:credit_card, user: create(:user)) }
+      let(:second_card) { create(:credit_card, user: create(:user)) }
+
+      it 'allows multiple defaults' do
+        Spree::Deprecation.silence do
+          first_card.default = true
+          second_card.default = true
+        end
+
+        expect(default_with_silence(first_card)).to be_truthy
+        expect(default_with_silence(second_card)).to be_truthy
+      end
+    end
+
+    context 'without a user' do
+      let(:credit_card) { create(:credit_card) }
+
+      it 'raises' do
+        expect {
+          Spree::Deprecation.silence do
+            credit_card.default = true
+          end
+        }.to raise_error("Cannot set 'default' on a credit card without a user")
+      end
+    end
   end
 end

data/spec/models/spree/gateway_spec.rb

@@ -85,7 +85,9 @@ describe Spree::Gateway, type: :model do
     context 'order is not complete but credit card has user' do
       let(:cc_user) { user }
       let(:completed_at) { nil }
-
+      before do
+        cc_user.wallet.add(cc)
+      end
       it "finds credit cards associated to the user" do
         expect(payment_method.reusable_sources(payment.order)).to eq [cc]
       end

data/spec/models/spree/inventory_unit_spec.rb

@@ -5,6 +5,15 @@ describe Spree::InventoryUnit, type: :model do
   let(:stock_item) { stock_location.stock_items.order(:id).first }
   let(:line_item) { create(:line_item, variant: stock_item.variant) }
 
+  describe ".cancelable" do
+    let!(:pending_unit) { create(:inventory_unit, pending: true) }
+    let!(:non_pending_unit) { create(:inventory_unit, pending: false) }
+
+    subject { described_class.cancelable }
+
+    it { is_expected.to contain_exactly(non_pending_unit) }
+  end
+
   context "#backordered_for_stock_item" do
     let(:order) do
       order = create(:order, state: 'complete', ship_address: create(:ship_address))
@@ -289,11 +298,10 @@ describe Spree::InventoryUnit, type: :model do
       expect { inventory_unit.reload }.not_to raise_error
     end
 
-    it "cannot be destroyed if its shipment is ready" do
+    it "can be destroyed if its shipment is ready" do
       inventory_unit = create(:order_ready_to_ship).inventory_units.first
-      expect(inventory_unit.destroy).to eq false
-      expect(inventory_unit.errors.full_messages.join).to match /Cannot destroy/
-      expect { inventory_unit.reload }.not_to raise_error
+      expect(inventory_unit.destroy).to be_truthy
+      expect { inventory_unit.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
     it "cannot be destroyed if its shipment is shipped" do

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

@@ -254,11 +254,6 @@ describe Spree::Order, type: :model do
           allow(order).to receive(:ensure_available_shipping_rates) { true }
         end
 
-        it 'should invoke set_shipment_cost' do
-          expect(order).to receive(:set_shipments_cost)
-          order.next!
-        end
-
         it 'should update shipment_total' do
           expect { order.next! }.to change{ order.shipment_total }.by(10.00)
         end
@@ -300,7 +295,6 @@ describe Spree::Order, type: :model do
         end
 
         it "transitions to payment" do
-          expect(order).to receive(:set_shipments_cost)
           order.next!
           assert_state_changed(order, 'delivery', 'payment')
           expect(order.state).to eq('payment')
@@ -333,7 +327,7 @@ describe Spree::Order, type: :model do
         context "with a shipment that has a price" do
           before do
             shipment.shipping_rates.first.update_column(:cost, 10)
-            order.set_shipments_cost
+            order.update!
           end
 
           it "transitions to payment" do
@@ -345,7 +339,6 @@ describe Spree::Order, type: :model do
         context "with a shipment that is free" do
           before do
             shipment.shipping_rates.first.update_column(:cost, 0)
-            order.set_shipments_cost
           end
 
           it "skips payment, transitions to confirm" do
@@ -362,8 +355,9 @@ describe Spree::Order, type: :model do
       let(:default_credit_card) { create(:credit_card) }
 
       before do
-        user = Spree::LegacyUser.new(email: 'spree@example.org', bill_address: user_bill_address)
-        allow(user).to receive(:default_credit_card) { default_credit_card }
+        user = create(:user, email: 'spree@example.org', bill_address: user_bill_address)
+        wallet_payment_source = user.wallet.add(default_credit_card)
+        user.wallet.default_wallet_payment_source = wallet_payment_source
         order.user = user
 
         allow(order).to receive_messages(payment_required?: true)
@@ -533,24 +527,9 @@ describe Spree::Order, type: :model do
           order.save!
         end
 
-        context 'when the exchange is for an unreturned item' do
-          before do
-            order.shipments.first.update_attributes!(created_at: order.created_at - 1.day)
-            expect(order.unreturned_exchange?).to eq true
-          end
-
-          it 'allows the order to complete' do
-            order.complete!
-
-            expect(order).to be_complete
-          end
-        end
-
-        context 'when the exchange is not for an unreturned item' do
-          it 'does not allow the order to completed' do
-            expect { order.complete! }.to raise_error Spree::Order::InsufficientStock
-            expect(order.payments.first.state).to eq('checkout')
-          end
+        it 'does not allow the order to completed' do
+          expect { order.complete! }.to raise_error Spree::Order::InsufficientStock
+          expect(order.payments.first.state).to eq('checkout')
         end
       end
     end
@@ -576,13 +555,13 @@ describe Spree::Order, type: :model do
       it "makes the current credit card a user's default credit card" do
         order.complete!
         expect(order.state).to eq 'complete'
-        expect(order.user.reload.default_credit_card.try(:id)).to eq(order.credit_cards.first.id)
+        expect(order.user.reload.wallet.default_wallet_payment_source.payment_source).to eq(order.credit_cards.first)
       end
 
-      it "does not assign a default credit card if temporary_credit_card is set" do
-        order.temporary_credit_card = true
+      it "does not assign a default credit card if temporary_payment_source is set" do
+        order.temporary_payment_source = true
         order.complete!
-        expect(order.user.reload.default_credit_card).to be_nil
+        expect(order.user.reload.wallet.default_wallet_payment_source).to be_nil
       end
     end
 

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

@@ -18,7 +18,7 @@ module Spree
         end
       end
 
-      context "when :tax_using_ship_address => true" do
+      context "when tax_using_ship_address: true" do
         before { Spree::Config.set(tax_using_ship_address: true) }
 
         it "should calculate using ship_address" do
@@ -30,7 +30,7 @@ module Spree
         end
       end
 
-      context "when :tax_using_ship_address => false" do
+      context "when tax_using_ship_address: false" do
         before { Spree::Config.set(tax_using_ship_address: false) }
 
         it "should calculate using bill_address" do