spree_core 3.0.9 → 3.2.0

data/spec/models/spree/taxon_spec.rb

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe Spree::Taxon, :type => :model do
-  let(:taxon) { FactoryGirl.build(:taxon, :name => "Ruby on Rails") }
+describe Spree::Taxon, type: :model do
+  let(:taxon) { FactoryGirl.build(:taxon, name: "Ruby on Rails") }
 
   describe '#to_param' do
     subject { super().to_param }
@@ -23,8 +23,19 @@ describe Spree::Taxon, :type => :model do
       expect(taxon.permalink).to eql 'ni-hao'
     end
 
+    it "stores old slugs in FriendlyIds history" do
+      # Stub out unrelated methods that cannot handle a save without an id
+      allow(subject).to receive(:set_depth!)
+      # create_slug is a private method, included by FriendlyId::History
+      # it's effect is rather complex and dependent on state and config.
+      # However, when a new slug is set, it should call slugs.create!
+      expect(subject.slugs).to receive(:create!)
+      subject.permalink = "custom-slug"
+      subject.run_callbacks :save
+    end
+
     context "with parent taxon" do
-      let(:parent) { FactoryGirl.build(:taxon, :permalink => "brands") }
+      let(:parent) { FactoryGirl.build(:taxon, permalink: "brands") }
       before       { allow(taxon).to receive_messages parent: parent }
 
       it "should set permalink correctly when taxon has parent" do
@@ -68,7 +79,7 @@ describe Spree::Taxon, :type => :model do
     let(:taxonomy) { create(:taxonomy) }
 
     it "does not error out" do
-      expect { taxonomy.root.children.unscoped.where(:name => "Some name").first_or_create }.not_to raise_error
+      expect { taxonomy.root.children.unscoped.where(name: "Some name").first_or_create }.not_to raise_error
     end
   end
 end

data/spec/models/spree/taxonomy_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Spree::Taxonomy, :type => :model do
+describe Spree::Taxonomy, type: :model do
   context "#destroy" do
     before do
        @taxonomy = create(:taxonomy)
        @root_taxon = @taxonomy.root
-       @child_taxon = create(:taxon, :taxonomy_id => @taxonomy.id, :parent => @root_taxon)
+       @child_taxon = create(:taxon, taxonomy_id: @taxonomy.id, parent: @root_taxon)
     end
 
     it "should destroy all associated taxons" do

data/spec/models/spree/tracker_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Tracker, :type => :model do
+describe Spree::Tracker, type: :model do
   describe "current" do
     before(:each) { @tracker = create(:tracker) }
 

data/spec/models/spree/user_spec.rb

@@ -1,40 +1,46 @@
 require 'spec_helper'
 
-describe Spree::LegacyUser, :type => :model do
+describe Spree::LegacyUser, type: :model do
   # Regression test for #2844 + #3346
-  context "#last_incomplete_order" do
+  context '#last_incomplete_order' do
     let!(:user) { create(:user) }
     let!(:order) { create(:order, bill_address: create(:address), ship_address: create(:address)) }
 
-    let!(:order_1) { create(:order, :created_at => 1.day.ago, :user => user, :created_by => user) }
-    let!(:order_2) { create(:order, :user => user, :created_by => user) }
-    let!(:order_3) { create(:order, :user => user, :created_by => create(:user)) }
+    let(:order_1) { create(:order, created_at: 1.day.ago, user: user, created_by: user) }
+    let(:order_2) { create(:order, user: user, created_by: user) }
+    let(:order_3) { create(:order, user: user, created_by: create(:user)) }
 
-    it "returns correct order" do
-      expect(user.last_incomplete_spree_order).to eq order_3
+    it 'returns correct order' do
+      Timecop.scale(3600) do
+        order_1
+        order_2
+        order_3
+
+        expect(user.last_incomplete_spree_order).to eq order_3
+      end
     end
 
-    context "persists order address" do
-      it "copies over order addresses" do
-        expect {
+    context 'persists order address' do
+      it 'copies over order addresses' do
+        expect do
           user.persist_order_address(order)
-        }.to change { Spree::Address.count }.by(2)
+        end.to change { Spree::Address.count }.by(2)
 
         expect(user.bill_address).to eq order.bill_address
         expect(user.ship_address).to eq order.ship_address
       end
 
-      it "doesnt create new addresses if user has already" do
-        user.update_column(:bill_address_id, create(:address))
-        user.update_column(:ship_address_id, create(:address))
+      it 'doesnt create new addresses if user has already' do
+        user.update_column(:bill_address_id, create(:address).id)
+        user.update_column(:ship_address_id, create(:address).id)
         user.reload
 
-        expect {
+        expect do
           user.persist_order_address(order)
-        }.not_to change { Spree::Address.count }
+        end.not_to change { Spree::Address.count }
       end
 
-      it "set both bill and ship address id on subject" do
+      it 'set both bill and ship address id on subject' do
         user.persist_order_address(order)
 
         expect(user.bill_address_id).not_to be_blank
@@ -42,17 +48,17 @@ describe Spree::LegacyUser, :type => :model do
       end
     end
 
-    context "payment source" do
+    context 'payment source' do
       let(:payment_method) { create(:credit_card_payment_method) }
       let!(:cc) do
         create(:credit_card, user_id: user.id, payment_method: payment_method, gateway_customer_profile_id: "2342343")
       end
 
-      it "has payment sources" do
+      it 'has payment sources' do
         expect(user.payment_sources.first.gateway_customer_profile_id).not_to be_empty
       end
 
-      it "drops payment source" do
+      it 'drops payment source' do
         user.drop_payment_source cc
         expect(cc.gateway_customer_profile_id).to be_nil
       end
@@ -60,14 +66,14 @@ describe Spree::LegacyUser, :type => :model do
   end
 end
 
-describe Spree.user_class, :type => :model do
-  context "reporting" do
-    let(:order_value) { BigDecimal.new("80.94") }
+describe Spree.user_class, type: :model do
+  context 'reporting' do
+    let(:order_value) { BigDecimal.new('80.94') }
     let(:order_count) { 4 }
     let(:orders) { Array.new(order_count, double(total: order_value)) }
 
     before do
-      allow(orders).to receive(:pluck).with(:total).and_return(orders.map(&:total))
+      allow(orders).to receive(:sum).with(:total).and_return(orders.sum(&:total))
       allow(orders).to receive(:count).and_return(orders.length)
     end
 
@@ -75,56 +81,123 @@ describe Spree.user_class, :type => :model do
       allow(subject).to receive(:orders).and_return(double(complete: orders))
     end
 
-    describe "#lifetime_value" do
-      context "with orders" do
+    describe '#lifetime_value' do
+      context 'with orders' do
         before { load_orders }
         it "returns the total of completed orders for the user" do
           expect(subject.lifetime_value).to eq (order_count * order_value)
         end
       end
-      context "without orders" do
-        it "returns 0.00" do
+      context 'without orders' do
+        it 'returns 0.00' do
           expect(subject.lifetime_value).to eq BigDecimal("0.00")
         end
       end
     end
 
-    describe "#display_lifetime_value" do
-      it "returns a Spree::Money version of lifetime_value" do
-        value = BigDecimal("500.05")
+    describe '#display_lifetime_value' do
+      it 'returns a Spree::Money version of lifetime_value' do
+        value = BigDecimal('500.05')
         allow(subject).to receive(:lifetime_value).and_return(value)
         expect(subject.display_lifetime_value).to eq Spree::Money.new(value)
       end
     end
 
-    describe "#order_count" do
+    describe '#order_count' do
       before { load_orders }
-      it "returns the count of completed orders for the user" do
+      it 'returns the count of completed orders for the user' do
         expect(subject.order_count).to eq BigDecimal(order_count)
       end
     end
 
-    describe "#average_order_value" do
-      context "with orders" do
+    describe '#average_order_value' do
+      context 'with orders' do
         before { load_orders }
-        it "returns the average completed order price for the user" do
+        it 'returns the average completed order price for the user' do
           expect(subject.average_order_value).to eq order_value
         end
       end
-      context "without orders" do
-        it "returns 0.00" do
-          expect(subject.average_order_value).to eq BigDecimal("0.00")
+      context 'without orders' do
+        it 'returns 0.00' do
+          expect(subject.average_order_value).to eq BigDecimal('0.00')
         end
       end
     end
 
     describe "#display_average_order_value" do
       before { load_orders }
-      it "returns a Spree::Money version of average_order_value" do
-        value = BigDecimal("500.05")
+      it 'returns a Spree::Money version of average_order_value' do
+        value = BigDecimal('500.05')
         allow(subject).to receive(:average_order_value).and_return(value)
         expect(subject.display_average_order_value).to eq Spree::Money.new(value)
       end
     end
   end
+
+  describe '#total_available_store_credit' do
+    context 'user does not have any associated store credits' do
+      subject { create(:user) }
+
+      it 'returns 0' do
+        expect(subject.total_available_store_credit).to be_zero
+      end
+    end
+
+    context 'user has several associated store credits' do
+      let(:user) { create(:user) }
+      let(:amount) { 120.25 }
+      let(:additional_amount) { 55.75 }
+      let(:store_credit) { create(:store_credit, user: user, amount: amount, amount_used: 0.0) }
+      let!(:additional_store_credit) { create(:store_credit, user: user, amount: additional_amount, amount_used: 0.0) }
+
+      subject { store_credit.user }
+
+      context 'part of the store credit has been used' do
+        let(:amount_used) { 35.00 }
+
+        before { store_credit.update_attributes(amount_used: amount_used) }
+
+        context 'part of the store credit has been authorized' do
+          let(:authorized_amount) { 10 }
+
+          before { additional_store_credit.update_attributes(amount_authorized: authorized_amount) }
+
+          it 'returns sum of amounts minus used amount and authorized amount' do
+            available_store_credit = amount + additional_amount - amount_used - authorized_amount
+            expect(subject.total_available_store_credit.to_f).to eq available_store_credit
+          end
+        end
+
+        context 'there are no authorized amounts on any of the store credits' do
+          it 'returns sum of amounts minus used amount' do
+            expect(subject.total_available_store_credit.to_f).to eq (amount + additional_amount - amount_used)
+          end
+        end
+      end
+
+      context 'store credits have never been used' do
+        context 'part of the store credit has been authorized' do
+          let(:authorized_amount) { 10 }
+
+          before { additional_store_credit.update_attributes(amount_authorized: authorized_amount) }
+
+          it 'returns sum of amounts minus authorized amount' do
+            expect(subject.total_available_store_credit.to_f).to eq (amount + additional_amount - authorized_amount)
+          end
+        end
+
+        context 'there are no authorized amounts on any of the store credits' do
+          it 'returns sum of amounts' do
+            expect(subject.total_available_store_credit.to_f).to eq (amount + additional_amount)
+          end
+        end
+      end
+
+      context 'all store credits have never been used or authorized' do
+        it 'returns sum of amounts' do
+          expect(subject.total_available_store_credit.to_f).to eq (amount + additional_amount)
+        end
+      end
+    end
+  end
 end