solidus_core 2.0.3 → 2.1.0.beta1

data/spec/models/spree/payment_method_spec.rb

@@ -1,30 +1,101 @@
 require 'spec_helper'
 
 describe Spree::PaymentMethod, type: :model do
-  describe ".available" do
-    let!(:payment_method_nil_display)  { create(:payment_method, active: true, display_on: nil) }
-    let!(:payment_method_both_display) { create(:payment_method, active: true, display_on: 'both') }
-    let!(:payment_method_front_display){ create(:payment_method, active: true, display_on: 'front_end') }
-    let!(:payment_method_back_display) { create(:payment_method, active: true, display_on: 'back_end') }
+  let!(:payment_method_nil_display)  { create(:payment_method, active: true,
+                                              available_to_users: true,
+                                              available_to_admin: true) }
+  let!(:payment_method_both_display) { create(:payment_method, active: true,
+                                              available_to_users: true,
+                                              available_to_admin: true) }
+  let!(:payment_method_front_display){ create(:payment_method, active: true,
+                                              available_to_users: true,
+                                              available_to_admin: false) }
+  let!(:payment_method_back_display) { create(:payment_method, active: true,
+                                              available_to_users: false,
+                                              available_to_admin: true) }
+
+  describe "available_to_[<users>, <admin>, <store>]" do
+    context "when searching for payment methods available to users and admins" do
+      subject { Spree::PaymentMethod.available_to_users.available_to_admin }
+
+      it { is_expected.to contain_exactly(payment_method_both_display, payment_method_nil_display) }
+
+      context "with a store" do
+        let!(:extra_payment_method_both_display) { create(:payment_method, active: true,
+                                                    available_to_users: true,
+                                                    available_to_admin: true) }
+        let!(:store_1) do
+          create(:store, payment_methods:[payment_method_nil_display,
+                                          payment_method_both_display,
+                                          payment_method_front_display,
+                                          payment_method_back_display])
+        end
+
+        subject { Spree::PaymentMethod.available_to_store( store_1 ).available_to_users.available_to_admin }
+
+        it { is_expected.to contain_exactly(payment_method_both_display, payment_method_nil_display) }
+
+        context "when the store has no payment methods" do
+          subject { Spree::PaymentMethod.available_to_store(store_without_payment_methods) }
+          let!(:store_without_payment_methods) do
+            create(:store, payment_methods:[])
+          end
+
+          it "returns all payment methods" do
+            expect(subject.all.size).to eq(5)
+          end
+
+          it "is further scopeable for admin availability" do
+            expect(subject.available_to_admin).not_to include(payment_method_front_display)
+          end
+
+          it "is further scopeable for users availability" do
+            expect(subject.available_to_users).not_to include(payment_method_back_display)
+          end
+        end
+      end
+    end
 
+    context "when searching for payment methods available to users" do
+      subject { Spree::PaymentMethod.available_to_users }
+
+      it { is_expected.to contain_exactly(payment_method_front_display, payment_method_both_display, payment_method_nil_display) }
+    end
+
+    context "when searching for payment methods available to admin" do
+      subject { Spree::PaymentMethod.available_to_admin }
+
+      it { is_expected.to contain_exactly(payment_method_back_display, payment_method_both_display, payment_method_nil_display)}
+    end
+  end
+
+  describe ".available" do
     it "should have 4 total methods" do
       expect(Spree::PaymentMethod.all.size).to eq(4)
     end
 
     it "should return all methods available to front-end/back-end when no parameter is passed" do
-      expect(Spree::PaymentMethod.available.size).to eq(2)
+      Spree::Deprecation.silence do
+        expect(Spree::PaymentMethod.available.size).to eq(2)
+      end
     end
 
-    it "should return all methods available to front-end/back-end when display_on = :both" do
-      expect(Spree::PaymentMethod.available(:both).size).to eq(2)
+    it "should return all methods available to front-end/back-end when passed :both" do
+      Spree::Deprecation.silence do
+        expect(Spree::PaymentMethod.available(:both).size).to eq(2)
+      end
     end
 
-    it "should return all methods available to front-end when display_on = :front_end" do
-      expect(Spree::PaymentMethod.available(:front_end).size).to eq(2)
+    it "should return all methods available to front-end when passed :front_end" do
+      Spree::Deprecation.silence do
+        expect(Spree::PaymentMethod.available(:front_end).size).to eq(3)
+      end
     end
 
-    it "should return all methods available to back-end when display_on = :back_end" do
-      expect(Spree::PaymentMethod.available(:back_end).size).to eq(2)
+    it "should return all methods available to back-end when passed :back_end" do
+      Spree::Deprecation.silence do
+        expect(Spree::PaymentMethod.available(:back_end).size).to eq(3)
+      end
     end
 
     context 'with stores' do
@@ -51,14 +122,33 @@ describe Spree::PaymentMethod, type: :model do
       context 'when the store is specified' do
         context 'when the store has payment methods' do
           it 'finds the payment methods for the store' do
-            expect(Spree::PaymentMethod.available(:both, store: store_1)).to match_array(
-              [payment_method_nil_display, payment_method_both_display]
-            )
+            Spree::Deprecation.silence do
+              expect(Spree::PaymentMethod.available(:both, store: store_1)).to match_array(
+                [payment_method_nil_display, payment_method_both_display]
+              )
+            end
           end
         end
 
         context "when store does not have payment_methods" do
           it "returns all matching payment methods regardless of store" do
+            Spree::Deprecation.silence do
+              expect(Spree::PaymentMethod.available(:both)).to match_array(
+                [
+                  payment_method_nil_display,
+                  payment_method_both_display,
+                  store_2_payment_method,
+                  no_store_payment_method
+                ]
+              )
+            end
+          end
+        end
+      end
+
+      context 'when the store is not specified' do
+        it "returns all matching payment methods regardless of store" do
+          Spree::Deprecation.silence do
             expect(Spree::PaymentMethod.available(:both)).to match_array(
               [
                 payment_method_nil_display,
@@ -70,19 +160,6 @@ describe Spree::PaymentMethod, type: :model do
           end
         end
       end
-
-      context 'when the store is not specified' do
-        it "returns all matching payment methods regardless of store" do
-          expect(Spree::PaymentMethod.available(:both)).to match_array(
-            [
-              payment_method_nil_display,
-              payment_method_both_display,
-              store_2_payment_method,
-              no_store_payment_method
-            ]
-          )
-        end
-      end
     end
   end
 
@@ -143,4 +220,77 @@ describe Spree::PaymentMethod, type: :model do
       end
     end
   end
+
+  describe "display_on=" do
+    around do |example|
+      Spree::Deprecation.silence do
+        example.run
+      end
+    end
+    let(:payment) { described_class.new(display_on: display_on) }
+
+    context 'with empty string' do
+      let(:display_on) { "" }
+
+      it "should be available to admins" do
+        expect(payment.available_to_admin).to be true
+      end
+
+      it "should be available to users" do
+        expect(payment.available_to_users).to be true
+      end
+
+      it "should have the same value for display_on" do
+        expect(payment.display_on).to eq ""
+      end
+    end
+
+    context 'with "back_end"' do
+      let(:display_on) { "back_end" }
+
+      it "should be available to admins" do
+        expect(payment.available_to_admin).to be true
+      end
+
+      it "should not be available to users" do
+        expect(payment.available_to_users).to be false
+      end
+
+      it "should have the same value for display_on" do
+        expect(payment.display_on).to eq "back_end"
+      end
+    end
+
+    context 'with "front_end"' do
+      let(:display_on) { "front_end" }
+
+      it "should be available to admins" do
+        expect(payment.available_to_admin).to be false
+      end
+
+      it "should not be available to users" do
+        expect(payment.available_to_users).to be true
+      end
+
+      it "should have the same value for display_on" do
+        expect(payment.display_on).to eq "front_end"
+      end
+    end
+
+    context 'with any other string' do
+      let(:display_on) { "foobar" }
+
+      it "should be available to admins" do
+        expect(payment.available_to_admin).to be false
+      end
+
+      it "should not be available to users" do
+        expect(payment.available_to_users).to be false
+      end
+
+      it "should have none for display_on" do
+        expect(payment.display_on).to eq "none"
+      end
+    end
+  end
 end

data/spec/models/spree/payment_spec.rb

@@ -17,12 +17,12 @@ describe Spree::Payment, type: :model do
   let(:card) { create :credit_card }
 
   let(:payment) do
-    Spree::Payment.create! do |payment|
-      payment.source = card
-      payment.order = order
-      payment.payment_method = gateway
-      payment.amount = 5
-    end
+    payment = Spree::Payment.new
+    payment.source = card
+    payment.order = order
+    payment.payment_method = gateway
+    payment.amount = 5
+    payment
   end
 
   let(:amount_in_cents) { (payment.amount * 100).round }
@@ -39,6 +39,11 @@ describe Spree::Payment, type: :model do
     ActiveMerchant::Billing::Response.new(false, '', {}, {})
   end
 
+  before(:each) do
+    # So it doesn't create log entries every time a processing method is called
+    allow(payment.log_entries).to receive(:create!)
+  end
+
   context '.risky' do
     let!(:payment_1) { create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: 'Match') }
     let!(:payment_2) { create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: '') }
@@ -241,9 +246,8 @@ describe Spree::Payment, type: :model do
 
       it "should log the response" do
         payment.save!
-        expect {
-          payment.authorize!
-        }.to change { payment.log_entries.count }.by(1)
+        expect(payment.log_entries).to receive(:create!).with(details: anything)
+        payment.authorize!
       end
 
       describe 'billing_address option' do
@@ -351,9 +355,8 @@ describe Spree::Payment, type: :model do
 
       it "should log the response" do
         payment.save!
-        expect {
-          payment.purchase!
-        }.to change { payment.log_entries.count }.by(1)
+        expect(payment.log_entries).to receive(:create!).with(details: anything)
+        payment.purchase!
       end
 
       context "if successful" do
@@ -529,9 +532,8 @@ describe Spree::Payment, type: :model do
       end
 
       it "should log the response" do
-        expect {
-          payment.void_transaction!
-        }.to change { payment.log_entries.count }.by(1)
+        expect(payment.log_entries).to receive(:create!).with(details: anything)
+        payment.void_transaction!
       end
 
       context "if successful" do
@@ -653,13 +655,12 @@ describe Spree::Payment, type: :model do
     end
 
     context "completed orders" do
-      let(:payment_method) { create(:check_payment_method) }
       before { allow(order).to receive_messages completed?: true }
 
       it "updates payment_state and shipments" do
         expect(order.updater).to receive(:update_payment_state)
         expect(order.updater).to receive(:update_shipment_state)
-        Spree::Payment.create!(amount: 100, order: order, payment_method: payment_method)
+        Spree::Payment.create(amount: 100, order: order)
       end
     end
 
@@ -690,8 +691,6 @@ describe Spree::Payment, type: :model do
         end
 
         it "should not try to create profiles on old failed payment attempts" do
-          order.payments.destroy_all
-
           allow_any_instance_of(Spree::Payment).to receive(:payment_method) { gateway }
 
           order.payments.create!(
@@ -744,6 +743,23 @@ describe Spree::Payment, type: :model do
       invalid_payment.save
       expect(payment.reload.state).to eq('checkout')
     end
+
+    describe "invalidating payments updates in memory objects" do
+      before do
+        Spree::PaymentCreate.new(order, amount: 1).build.save!
+        expect(order.payments.map(&:state)).to contain_exactly(
+          'checkout'
+        )
+        Spree::PaymentCreate.new(order, amount: 2).build.save!
+      end
+
+      it 'should not have stale payments' do
+        expect(order.payments.map(&:state)).to contain_exactly(
+          'invalid',
+          'checkout'
+        )
+      end
+    end
   end
 
   describe "#apply_source_attributes" do

data/spec/models/spree/permission_sets/configuration_display.rb

@@ -22,7 +22,6 @@ describe Spree::PermissionSets::ConfigurationDisplay do
     it { is_expected.to be_able_to(:display, Spree::ShippingCategory) }
     it { is_expected.to be_able_to(:display, Spree::StockLocation) }
     it { is_expected.to be_able_to(:display, Spree::StockMovement) }
-    it { is_expected.to be_able_to(:display, Spree::Tracker) }
     it { is_expected.to be_able_to(:display, Spree::RefundReason) }
     it { is_expected.to be_able_to(:display, Spree::ReimbursementType) }
     it { is_expected.to be_able_to(:display, Spree::ReturnReason) }
@@ -38,7 +37,6 @@ describe Spree::PermissionSets::ConfigurationDisplay do
     it { is_expected.to be_able_to(:admin, Spree::ShippingCategory) }
     it { is_expected.to be_able_to(:admin, Spree::StockLocation) }
     it { is_expected.to be_able_to(:admin, Spree::StockMovement) }
-    it { is_expected.to be_able_to(:admin, Spree::Tracker) }
     it { is_expected.to be_able_to(:admin, Spree::RefundReason) }
     it { is_expected.to be_able_to(:admin, Spree::ReimbursementType) }
     it { is_expected.to be_able_to(:admin, Spree::ReturnReason) }
@@ -57,7 +55,6 @@ describe Spree::PermissionSets::ConfigurationDisplay do
     it { is_expected.not_to be_able_to(:display, Spree::ShippingCategory) }
     it { is_expected.not_to be_able_to(:display, Spree::StockLocation) }
     it { is_expected.not_to be_able_to(:display, Spree::StockMovement) }
-    it { is_expected.not_to be_able_to(:display, Spree::Tracker) }
     it { is_expected.not_to be_able_to(:display, Spree::RefundReason) }
     it { is_expected.not_to be_able_to(:display, Spree::ReimbursementType) }
     it { is_expected.not_to be_able_to(:display, Spree::ReturnReason) }
@@ -73,7 +70,6 @@ describe Spree::PermissionSets::ConfigurationDisplay do
     it { is_expected.not_to be_able_to(:admin, Spree::ShippingCategory) }
     it { is_expected.not_to be_able_to(:admin, Spree::StockLocation) }
     it { is_expected.not_to be_able_to(:admin, Spree::StockMovement) }
-    it { is_expected.not_to be_able_to(:admin, Spree::Tracker) }
     it { is_expected.not_to be_able_to(:admin, Spree::RefundReason) }
     it { is_expected.not_to be_able_to(:admin, Spree::ReimbursementType) }
     it { is_expected.not_to be_able_to(:admin, Spree::ReturnReason) }

data/spec/models/spree/permission_sets/configuration_management_spec.rb

@@ -22,7 +22,6 @@ describe Spree::PermissionSets::ConfigurationManagement do
     it { is_expected.to be_able_to(:manage, Spree::ShippingCategory) }
     it { is_expected.to be_able_to(:manage, Spree::StockLocation) }
     it { is_expected.to be_able_to(:manage, Spree::StockMovement) }
-    it { is_expected.to be_able_to(:manage, Spree::Tracker) }
     it { is_expected.to be_able_to(:manage, Spree::RefundReason) }
     it { is_expected.to be_able_to(:manage, Spree::ReimbursementType) }
     it { is_expected.to be_able_to(:manage, Spree::ReturnReason) }
@@ -41,7 +40,6 @@ describe Spree::PermissionSets::ConfigurationManagement do
     it { is_expected.not_to be_able_to(:manage, Spree::ShippingCategory) }
     it { is_expected.not_to be_able_to(:manage, Spree::StockLocation) }
     it { is_expected.not_to be_able_to(:manage, Spree::StockMovement) }
-    it { is_expected.not_to be_able_to(:manage, Spree::Tracker) }
     it { is_expected.not_to be_able_to(:manage, Spree::RefundReason) }
     it { is_expected.not_to be_able_to(:manage, Spree::ReimbursementType) }
     it { is_expected.not_to be_able_to(:manage, Spree::ReturnReason) }

data/spec/models/spree/permission_sets/product_display_spec.rb

@@ -17,7 +17,6 @@ describe Spree::PermissionSets::ProductDisplay do
     it { is_expected.to be_able_to(:display, Spree::ProductProperty) }
     it { is_expected.to be_able_to(:display, Spree::OptionType) }
     it { is_expected.to be_able_to(:display, Spree::Property) }
-    it { is_expected.to be_able_to(:display, Spree::Prototype) }
     it { is_expected.to be_able_to(:display, Spree::Taxonomy) }
     it { is_expected.to be_able_to(:display, Spree::Taxon) }
     it { is_expected.to be_able_to(:admin, Spree::Product) }
@@ -27,7 +26,6 @@ describe Spree::PermissionSets::ProductDisplay do
     it { is_expected.to be_able_to(:admin, Spree::ProductProperty) }
     it { is_expected.to be_able_to(:admin, Spree::OptionType) }
     it { is_expected.to be_able_to(:admin, Spree::Property) }
-    it { is_expected.to be_able_to(:admin, Spree::Prototype) }
     it { is_expected.to be_able_to(:admin, Spree::Taxonomy) }
     it { is_expected.to be_able_to(:admin, Spree::Taxon) }
     it { is_expected.to be_able_to(:edit, Spree::Product) }
@@ -41,7 +39,6 @@ describe Spree::PermissionSets::ProductDisplay do
     it { is_expected.not_to be_able_to(:display, Spree::ProductProperty) }
     it { is_expected.not_to be_able_to(:display, Spree::OptionType) }
     it { is_expected.not_to be_able_to(:display, Spree::Property) }
-    it { is_expected.not_to be_able_to(:display, Spree::Prototype) }
     it { is_expected.not_to be_able_to(:display, Spree::Taxonomy) }
     it { is_expected.not_to be_able_to(:display, Spree::Taxon) }
     it { is_expected.not_to be_able_to(:admin, Spree::Product) }
@@ -51,7 +48,6 @@ describe Spree::PermissionSets::ProductDisplay do
     it { is_expected.not_to be_able_to(:admin, Spree::ProductProperty) }
     it { is_expected.not_to be_able_to(:admin, Spree::OptionType) }
     it { is_expected.not_to be_able_to(:admin, Spree::Property) }
-    it { is_expected.not_to be_able_to(:admin, Spree::Prototype) }
     it { is_expected.not_to be_able_to(:admin, Spree::Taxonomy) }
     it { is_expected.not_to be_able_to(:admin, Spree::Taxon) }
     it { is_expected.not_to be_able_to(:edit, Spree::Product) }

data/spec/models/spree/permission_sets/product_management_spec.rb

@@ -17,7 +17,6 @@ describe Spree::PermissionSets::ProductManagement do
     it { is_expected.to be_able_to(:manage, Spree::ProductProperty) }
     it { is_expected.to be_able_to(:manage, Spree::OptionType) }
     it { is_expected.to be_able_to(:manage, Spree::Property) }
-    it { is_expected.to be_able_to(:manage, Spree::Prototype) }
     it { is_expected.to be_able_to(:manage, Spree::Taxonomy) }
     it { is_expected.to be_able_to(:manage, Spree::Taxon) }
     it { is_expected.to be_able_to(:manage, Spree::Classification) }
@@ -31,7 +30,6 @@ describe Spree::PermissionSets::ProductManagement do
     it { is_expected.not_to be_able_to(:manage, Spree::ProductProperty) }
     it { is_expected.not_to be_able_to(:manage, Spree::OptionType) }
     it { is_expected.not_to be_able_to(:manage, Spree::Property) }
-    it { is_expected.not_to be_able_to(:manage, Spree::Prototype) }
     it { is_expected.not_to be_able_to(:manage, Spree::Taxonomy) }
     it { is_expected.not_to be_able_to(:manage, Spree::Taxon) }
     it { is_expected.not_to be_able_to(:manage, Spree::Classification) }