solidus_core 1.3.2 → 1.4.0.beta1

data/spec/lib/spree/core/controller_helpers/payment_parameters_spec.rb

@@ -1,11 +1,29 @@
 require 'spec_helper'
 
-class FakeController < ApplicationController
-  include Spree::Core::ControllerHelpers::PaymentParameters
-end
-
 describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
-  controller(FakeController) {}
+  controller(ApplicationController) do
+    include Spree::Core::ControllerHelpers::PaymentParameters
+  end
+
+  let(:params_hash) { subject.permit!.to_h.deep_symbolize_keys }
+
+  shared_examples "unpermitted params" do
+    it "is unpermitted ActionController::Parameters" do
+      expect(subject).to be_a(ActionController::Parameters)
+      expect(subject).not_to be_permitted
+      expect(subject.to_h).to eq({})
+    end
+  end
+
+  shared_examples "unchanged params" do
+    let!(:original_param_hash) { params.dup.permit!.to_h.deep_symbolize_keys }
+
+    it 'returns the original hash' do
+      expect(params_hash).to eq(original_param_hash)
+    end
+
+    it_behaves_like "unpermitted params"
+  end
 
   describe '#move_payment_source_into_payments_attributes' do
     subject do
@@ -36,45 +54,45 @@ describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
     let(:credit_card_2_params) { attributes_for(:credit_card, name: 'Jordan2') }
 
     it 'produces the expected hash' do
-      expect(subject).to eq(
-        ActionController::Parameters.new(
-          order: {
-            payments_attributes: [
-              {
-                payment_method_id: payment_method_1.id.to_s,
-                source_attributes: credit_card_1_params
-              }
-            ],
-            other_order_param: 1
-          },
-          other_param: 2
-        )
+      expect(params_hash).to eq(
+        order: {
+          payments_attributes: [
+            {
+              payment_method_id: payment_method_1.id.to_s,
+              source_attributes: credit_card_1_params
+            }
+          ],
+          other_order_param: 1
+        },
+        other_param: 2
       )
     end
 
+    it_behaves_like "unpermitted params"
+
     context 'when payment_source is missing' do
       before { params.delete(:payment_source) }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
 
     context 'when order params are missing' do
       before { params.delete(:order) }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
 
     context 'when payment_attributes are missing' do
       before { params[:order].delete(:payments_attributes) }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
 
     context 'when the payment_method_id is missing' do
       before { params[:order][:payments_attributes][0].delete(:payment_method_id) }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
 
     context 'when the payment_method_id does not match a payments source' do
       before { params[:order][:payments_attributes][0][:payment_method_id] = -1 }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
   end
 
@@ -95,14 +113,35 @@ describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
     end
 
     it 'produces the expected hash' do
-      expect(subject).to eq(
-        ActionController::Parameters.new(
+      expect(params_hash).to eq(
+        order: {
+          payments_attributes: [
+            {
+              source_attributes: {
+                existing_card_id: '123',
+                verification_value: '456'
+              }
+            }
+          ],
+          other_order_param: 1
+        },
+        other_param: 2
+      )
+    end
+
+    it_behaves_like "unpermitted params"
+
+    context 'when cvc_confirm is missing' do
+      before { params.delete(:cvc_confirm) }
+
+      it 'produces the expected hash' do
+        expect(params_hash).to eq(
           order: {
             payments_attributes: [
               {
                 source_attributes: {
                   existing_card_id: '123',
-                  verification_value: '456'
+                  verification_value: nil
                 }
               }
             ],
@@ -110,40 +149,19 @@ describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
           },
           other_param: 2
         )
-      )
-    end
-
-    context 'when cvc_confirm is missing' do
-      before { params.delete(:cvc_confirm) }
-
-      it 'produces the expected hash' do
-        expect(subject).to eq(
-          ActionController::Parameters.new(
-            order: {
-              payments_attributes: [
-                {
-                  source_attributes: {
-                    existing_card_id: '123',
-                    verification_value: nil
-                  }
-                }
-              ],
-              other_order_param: 1
-            },
-            other_param: 2
-          )
-        )
       end
+
+      it_behaves_like "unpermitted params"
     end
 
     context 'when order params are missing' do
       before { params.delete(:order) }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
 
     context 'when existing_card is missing' do
       before { params[:order].delete(:existing_card) }
-      it('returns the original hash') { expect(subject).to eq(params) }
+      it_behaves_like "unchanged params"
     end
   end
 
@@ -164,14 +182,12 @@ describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
     let(:order) { create(:order_with_line_items, line_items_price: 101.00, line_items_count: 1, shipment_cost: 0) }
 
     it 'produces the expected hash' do
-      expect(subject).to eq(
-        ActionController::Parameters.new(
-          order: {
-            payments_attributes: [{ amount: 101 }],
-            other_order_param: 1
-          },
-          other_param: 2
-        )
+      expect(params_hash).to eq(
+        order: {
+          payments_attributes: [{ amount: 101 }],
+          other_order_param: 1
+        },
+        other_param: 2
       )
     end
   end

data/spec/lib/spree/core/delegate_belongs_to_spec.rb

@@ -8,7 +8,7 @@ module Spree
   class DelegateBelongsToStubModel < Spree::Base
     self.table_name = "spree_payment_methods"
     belongs_to :product
-    ActiveSupport::Deprecation.silence do
+    Spree::Deprecation.silence do
       delegate_belongs_to :product, :name
     end
   end

data/spec/lib/spree/core/importer/order_spec.rb

@@ -123,8 +123,10 @@ module Spree
         params = { line_items_attributes: line_items }
 
         expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /Validation failed/
+          Spree::Deprecation.silence do
+            Importer::Order.import(user, params)
+          end
+        }.to raise_exception ActiveRecord::RecordInvalid
       end
 
       it 'can build an order from API with variant sku' do

data/spec/lib/spree/core/stock_configuration_spec.rb

@@ -1,6 +1,23 @@
 require 'spec_helper'
 
 RSpec.describe Spree::Core::StockConfiguration do
+  describe '#coordinator_class' do
+    let(:stock_configuration) { described_class.new }
+    subject { stock_configuration.coordinator_class }
+
+    it "returns Spree::Stock::Coordinator" do
+      is_expected.to be ::Spree::Stock::Coordinator
+    end
+
+    context "with another constant name assiged" do
+      MyCoordinator = Class.new
+      before { stock_configuration.coordinator_class = MyCoordinator.to_s }
+
+      it "returns the constant" do
+        is_expected.to be MyCoordinator
+      end
+    end
+  end
   describe '#estimator_class' do
     let(:stock_configuration) { described_class.new }
     subject { stock_configuration.estimator_class }

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

@@ -8,41 +8,236 @@ RSpec.describe 'order factory' do
     let(:factory) { :order }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order.bill_address).to be_present
+        expect(order.ship_address).to be_present
+        expect(order.user).to be_present
+        expect(order.email).to be_present
+        expect(order.email).to eq(order.user.email)
+        expect(order.state).to eq "cart"
+        expect(order.store).to be_present
+        expect(order).not_to be_completed
+      end
+    end
   end
 
   describe 'order with totals' do
     let(:factory) { :order_with_totals }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        # This factory is terrbily named
+        expect(order.total).to eq 0
+        expect(order.line_items.count).to eq 1
+      end
+    end
   end
 
   describe 'order with line items' do
     let(:factory) { :order_with_line_items }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order.line_items.count).to eq 1
+        expect(order.line_items[0]).to have_attributes(
+          quantity: 1,
+          price: 10
+        )
+
+        expect(order.shipments.count).to eq 1
+        expect(order.shipments[0]).to have_attributes(
+          amount: 100
+        )
+
+        expect(order.shipments[0].inventory_units.count).to eq(1)
+        expect(order.shipments[0].inventory_units[0]).to have_attributes(
+          order: order,
+          shipment: order.shipments[0],
+          line_item: order.line_items[0],
+          variant: order.line_items[0].variant,
+          state: 'on_hand'
+        )
+
+        expect(order).to have_attributes(
+          item_total: 10,
+          ship_total: 100,
+          total: 110,
+          state: 'cart' # this isn't realistic
+        )
+      end
+    end
+  end
+
+  describe 'order ready to complete' do
+    let(:factory) { :order_ready_to_complete }
+
+    it_behaves_like 'a working factory'
+
+    it "is completable" do
+      order = create(factory)
+
+      expect { order.complete! }.to change {
+        order.complete?
+      }.from(false).to(true)
+    end
   end
 
   describe 'completed order with totals' do
     let(:factory) { :completed_order_with_totals }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order).to be_completed
+        expect(order).to have_attributes(
+          item_total: 10,
+          ship_total: 100,
+          total: 110,
+          state: 'complete'
+        )
+      end
+    end
   end
 
   describe 'completed order with pending payment' do
     let(:factory) { :completed_order_with_pending_payment }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order).to be_completed
+        expect(order).to have_attributes(
+          payment_state: 'balance_due',
+          total: 110,
+          payment_total: 0 # payment is still pending
+        )
+
+        expect(order.payments.count).to eq 1
+        expect(order.payments[0]).to have_attributes(
+          amount: 110,
+          state: 'pending'
+        )
+      end
+    end
   end
 
   describe 'order ready to ship' do
     let(:factory) { :order_ready_to_ship }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order).to be_completed
+        expect(order).to have_attributes(
+          total: 110,
+          payment_total: 110,
+          payment_state: "paid",
+          shipment_state: "ready"
+        )
+
+        expect(order.payments.count).to eq 1
+        expect(order.payments[0]).to have_attributes(
+          amount: 110,
+          state: 'completed'
+        )
+
+        expect(order.shipments.count).to eq 1
+        expect(order.shipments[0]).to have_attributes(
+          state: 'ready'
+        )
+      end
+    end
+
+    it "can be shipped" do
+      order = create(factory)
+      order.shipments[0].ship
+      aggregate_failures do
+        expect(order.shipment_state).to eq "shipped"
+        expect(order.shipments[0]).to be_shipped
+      end
+    end
   end
 
   describe 'shipped order' do
     let(:factory) { :shipped_order }
 
     it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order).to be_completed
+        expect(order).to have_attributes(
+          total: 110,
+          payment_total: 110,
+          payment_state: "paid"
+        )
+
+        expect(order.payments.count).to eq 1
+        expect(order.payments[0]).to have_attributes(
+          amount: 110,
+          state: 'completed'
+        )
+
+        expect(order.shipments.count).to eq 1
+        expect(order.shipments[0]).to have_attributes(
+          state: 'shipped'
+        )
+
+        expect(order.cartons.count).to eq 1
+      end
+    end
+  end
+
+  describe 'completed order with promotion' do
+    let(:factory) { :completed_order_with_promotion }
+
+    it_behaves_like 'a working factory'
+
+    it "has the expected attributes" do
+      order = create(factory)
+      aggregate_failures do
+        expect(order).to be_completed
+        expect(order).to be_complete
+
+        expect(order.order_promotions.count).to eq(1)
+        order_promotion = order.order_promotions[0]
+        expect(order_promotion.promotion_code.promotion).to eq order_promotion.promotion
+      end
+    end
+
+    context 'with a promotion with an action' do
+      let(:promotion) { create(:promotion, :with_line_item_adjustment) }
+      it "has the expected attributes" do
+        order = create(factory, promotion: promotion)
+        aggregate_failures do
+          expect(order).to be_completed
+          expect(order).to be_complete
+
+          expect(order.line_items[0].adjustments.count).to eq 1
+          adjustment = order.line_items[0].adjustments[0]
+          expect(adjustment).to have_attributes(
+            amount: -10,
+            eligible: true,
+            order_id: order.id
+          )
+        end
+      end
+    end
   end
 end

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

@@ -8,6 +8,12 @@ RSpec.describe 'payment factory' do
     let(:factory) { :payment }
 
     it_behaves_like 'a working factory'
+
+    it "assigns the Order's user to the created Credit Card" do
+      payment = create(factory)
+      expect(payment.source.user).to be_present
+      expect(payment.source.user).to eq payment.order.user
+    end
   end
 
   describe 'check payment' do

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

@@ -9,4 +9,10 @@ RSpec.describe 'reimbursement factory' do
 
     it_behaves_like 'a working factory'
   end
+
+  describe 'total' do
+    subject { FactoryGirl.create(:reimbursement).total }
+
+    it { is_expected.to be_present }
+  end
 end

data/spec/lib/spree/migrations_spec.rb

@@ -12,24 +12,18 @@ module Spree
 
     subject { described_class.new(config, "spree") }
 
-    before do
-      expect(File).to receive(:directory?).with(app_dir).and_return true
-    end
-
-    it "warns about missing migrations" do
+    it "detects missing migrations" do
       expect(Dir).to receive(:entries).with(app_dir).and_return app_migrations
       expect(Dir).to receive(:entries).with(engine_dir).and_return engine_migrations
 
-      silence_stream(STDOUT) {
-        expect(subject.check).to eq true
-      }
+      expect(subject.missing_migrations.size).to eq 2
     end
 
     context "no missing migrations" do
       it "says nothing" do
         expect(Dir).to receive(:entries).with(engine_dir).and_return engine_migrations
         expect(Dir).to receive(:entries).with(app_dir).and_return(app_migrations + engine_migrations)
-        expect(subject.check).to eq nil
+        expect(subject.missing_migrations.size).to eq 0
       end
     end
   end

data/spec/lib/tasks/migrations/copy_shipped_shipments_to_cartons_spec.rb

@@ -49,7 +49,7 @@ describe 'spree:migrations:copy_shipped_shipments_to_cartons' do
 
       expect(carton.number).to eq "C#{shipped_shipment.number}"
       expect(carton.stock_location).to eq shipped_shipment.stock_location
-      expect(carton.address).to eq shipped_shipment.address
+      expect(carton.address).to eq shipped_shipment.order.ship_address
       expect(carton.shipping_method).to eq shipped_shipment.shipping_method
       expect(carton.tracking).to eq shipped_shipment.tracking
       expect(carton.shipped_at).to eq shipped_shipment.shipped_at

data/spec/mailers/carton_mailer_spec.rb

@@ -18,7 +18,7 @@ describe Spree::CartonMailer do
 
   context "deprecated signature" do
     it do
-      ActiveSupport::Deprecation.silence do
+      Spree::Deprecation.silence do
         mail = Spree::CartonMailer.shipped_email(carton.id)
         expect(mail.subject).to include "Shipment Notification"
       end

data/spec/mailers/order_mailer_spec.rb

@@ -30,14 +30,14 @@ describe Spree::OrderMailer, type: :mailer do
 
   it "confirm_email accepts an order id as an alternative to an Order object" do
     expect(Spree::Order).to receive(:find).with(order.id).and_return(order)
-    ActiveSupport::Deprecation.silence do
+    Spree::Deprecation.silence do
       Spree::OrderMailer.confirm_email(order.id).body
     end
   end
 
   it "cancel_email accepts an order id as an alternative to an Order object" do
     expect(Spree::Order).to receive(:find).with(order.id).and_return(order)
-    ActiveSupport::Deprecation.silence do
+    Spree::Deprecation.silence do
       Spree::OrderMailer.cancel_email(order.id).body
     end
   end

data/spec/mailers/reimbursement_mailer_spec.rb

@@ -30,7 +30,7 @@ describe Spree::ReimbursementMailer, type: :mailer do
 
         specify do
           reimbursement_email = Spree::ReimbursementMailer.reimbursement_email(reimbursement)
-          expect(reimbursement_email.body).to include("Caro Cliente,")
+          expect(reimbursement_email).to have_body_text("Caro Cliente,")
         end
       end
     end

data/spec/models/spree/address_spec.rb

@@ -308,6 +308,28 @@ describe Spree::Address, type: :model do
     end
   end
 
+  describe '.taxation_attributes' do
+    context 'both taxation and non-taxation attributes are present ' do
+      let(:address) { stub_model(Spree::Address, firstname: 'Michael', lastname: 'Jackson', state_id: 1, country_id: 2, zipcode: '12345') }
+
+      it 'removes the non-taxation attributes' do
+        expect(address.taxation_attributes).not_to eq('firstname' => 'Michael', 'lastname' => 'Jackson')
+      end
+
+      it 'returns only the taxation attributes' do
+        expect(address.taxation_attributes).to eq('state_id' => 1, 'country_id' => 2, 'zipcode' => '12345')
+      end
+    end
+
+    context 'taxation attributes are blank' do
+      let(:address) { stub_model(Spree::Address, firstname: 'Michael', lastname: 'Jackson') }
+
+      it 'returns a subset of the attributes with the correct keys and nil values' do
+        expect(address.taxation_attributes).to eq('state_id' => nil, 'country_id' => nil, 'zipcode' => nil)
+      end
+    end
+  end
+
   context '#country_iso=' do
     let(:address) { build(:address, country_id: nil) }
     let(:country) { create(:country, iso: 'ZW') }

data/spec/models/spree/adjustment_spec.rb

@@ -10,16 +10,6 @@ describe Spree::Adjustment, type: :model do
 
   let(:adjustment) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: order, order: order, amount: 5) }
 
-  context '#create & #destroy' do
-    let(:adjustment) { Spree::Adjustment.new(label: "Adjustment", amount: 5, order: order, adjustable: line_item) }
-
-    it 'calls #update_adjustable_adjustment_total' do
-      expect(adjustment).to receive(:update_adjustable_adjustment_total).twice
-      adjustment.save
-      adjustment.destroy
-    end
-  end
-
   context '#save' do
     let(:adjustment) { Spree::Adjustment.create(label: "Adjustment", amount: 5, order: order, adjustable: line_item) }
 

data/spec/models/spree/carton_spec.rb

@@ -57,7 +57,7 @@ describe Spree::Carton do
     subject { carton.shipment_numbers }
     let(:shipment) { carton.shipments.first }
 
-    it "returns a list of the order numbers it is associated to" do
+    it "returns a list of the shipment numbers it is associated to" do
       expect(subject).to eq [shipment.number]
     end
   end

data/spec/models/spree/country_spec.rb

@@ -14,8 +14,12 @@ describe Spree::Country, type: :model do
         Spree::Config[:default_country_id] = 2
       end
 
+      subject(:default_country) do
+        Spree::Deprecation.silence { described_class.default }
+      end
+
       it 'emits a deprecation warning' do
-        expect(ActiveSupport::Deprecation).to receive(:warn)
+        expect(Spree::Deprecation).to receive(:warn)
         default_country
       end
 
@@ -29,6 +33,10 @@ describe Spree::Country, type: :model do
         Spree::Config[:default_country_id] = 0
       end
 
+      subject(:default_country) do
+        Spree::Deprecation.silence { described_class.default }
+      end
+
       it 'loads the country configured by the ISO code' do
         expect(default_country).to eq(Spree::Country.find(2))
       end

data/spec/models/spree/gateway/bogus_spec.rb

@@ -6,7 +6,7 @@ module Spree
     let!(:cc) { create(:credit_card, payment_method: bogus, gateway_customer_profile_id: "BGS-RERTERT") }
 
     it "disable recurring contract by destroying payment source" do
-      ActiveSupport::Deprecation.silence do
+      Spree::Deprecation.silence do
         bogus.disable_customer_profile(cc)
       end
       expect(cc.gateway_customer_profile_id).to be_nil