spree_core 3.0.10 → 3.1.0.rc1

data/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb

@@ -120,7 +120,7 @@ module Spree
           end
 
           it "nullifies adjustments for completed orders" do
-            order = Order.create(completed_at: Time.now)
+            order = Order.create(completed_at: Time.current)
             adjustment = action.adjustments.create!(label: "Check",
                                                     amount: 0,
                                                     order: order,

data/spec/models/spree/promotion/rules/user_spec.rb

@@ -2,6 +2,14 @@ require 'spec_helper'
 
 describe Spree::Promotion::Rules::User, :type => :model do
   let(:rule) { Spree::Promotion::Rules::User.new }
+  let(:test_user) { create :user }
+
+  describe 'Associations' do
+    it 'should have many promotion_rule_users' do
+      is_expected.to have_many(:promotion_rule_users).with_foreign_key(:promotion_rule_id).
+        class_name('Spree::PromotionRuleUser').dependent(:destroy)
+    end
+  end
 
   context "#eligible?(order)" do
     let(:order) { Spree::Order.new }

data/spec/models/spree/promotion_action_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Spree::PromotionAction, :type => :model do
 
   it "should force developer to implement 'perform' method" do
-    expect { MyAction.new.perform }.to raise_error
+    expect { MyAction.new.perform }.to raise_error(NameError)
   end
 
 end

data/spec/models/spree/promotion_rule_spec.rb

@@ -12,7 +12,7 @@ module Spree
     end
 
     it "should force developer to implement eligible? method" do
-      expect { BadTestRule.new.eligible? }.to raise_error
+      expect { BadTestRule.new.eligible? }.to raise_error(ArgumentError)
     end
 
     it "validates unique rules for a promotion" do

data/spec/models/spree/promotion_rule_taxon_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Spree::PromotionRuleTaxon do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:promotion_rule) }
+    it { is_expected.to validate_presence_of(:taxon) }
+    it { is_expected.to validate_uniqueness_of(:promotion_rule_id).scoped_to(:taxon_id).allow_nil }
+  end
+end

data/spec/models/spree/promotion_rule_user_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Spree::PromotionRuleUser do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:promotion_rule) }
+    it { is_expected.to validate_presence_of(:user) }
+    it { is_expected.to validate_uniqueness_of(:user_id).scoped_to(:promotion_rule_id).allow_nil }
+  end
+end

data/spec/models/spree/promotion_spec.rb

@@ -26,34 +26,55 @@ describe Spree::Promotion, :type => :model do
     end
   end
 
-  describe ".coupons" do
-    it "scopes promotions with coupon code present only" do
-      promotion = Spree::Promotion.create! name: "test", code: ''
-      expect(Spree::Promotion.coupons).to be_empty
+  describe 'scopes' do
+    describe '.coupons' do
+      let!(:promotion_without_code) { Spree::Promotion.create! name: 'test', code: '' }
+      let!(:promotion_with_code) { Spree::Promotion.create! name: 'test1', code: 'code' }
 
-      promotion.update_column :code, "check"
-      expect(Spree::Promotion.coupons.first).to eq promotion
+      subject { Spree::Promotion.coupons }
+
+      it 'is expected to not include promotion without code' do
+        is_expected.to_not include(promotion_without_code)
+      end
+
+      it 'is expected to include promotion with code' do
+        is_expected.to include(promotion_with_code)
+      end
     end
-  end
 
-  describe ".applied" do
-    it "scopes promotions that have been applied to an order only" do
-      promotion = Spree::Promotion.create! name: "test", code: ''
-      expect(Spree::Promotion.applied).to be_empty
+    describe '.applied' do
+      let!(:promotion_not_applied) { Spree::Promotion.create! name: 'test', code: '' }
+      let(:order) { create(:order) }
+      let!(:promotion_applied) do
+        promotion = Spree::Promotion.create!(name: 'test1', code: '')
+        promotion.orders << order
+        promotion
+      end
+
+      subject { Spree::Promotion.applied }
+
+      it 'is expected to not include promotion not applied' do
+        is_expected.to_not include(promotion_not_applied)
+      end
 
-      promotion.orders << create(:order)
-      expect(Spree::Promotion.applied.first).to eq promotion
+      it 'is expected to include promotion applied' do
+        is_expected.to include(promotion_applied)
+      end
     end
-  end
 
-  describe ".advertised" do
-    let(:promotion) { create(:promotion) }
-    let(:advertised_promotion) { create(:promotion, :advertise => true) }
+    describe '.advertised' do
+      let!(:promotion_not_advertised) { Spree::Promotion.create! name: 'test', advertise: false }
+      let!(:promotion_advertised) { Spree::Promotion.create! name: 'test1', advertise: true }
 
-    it "only shows advertised promotions" do
-      advertised = Spree::Promotion.advertised
-      expect(advertised).to include(advertised_promotion)
-      expect(advertised).not_to include(promotion)
+      subject { Spree::Promotion.advertised }
+
+      it 'is expected to not include promotion not advertised' do
+        is_expected.to_not include(promotion_not_advertised)
+      end
+
+      it 'is expected to include promotion advertised' do
+        is_expected.to include(promotion_advertised)
+      end
     end
   end
 
@@ -130,7 +151,7 @@ describe Spree::Promotion, :type => :model do
 
     it "does activate if newer then order" do
       expect(@action1).to receive(:perform).with(@payload)
-      promotion.created_at = DateTime.now + 2
+      promotion.created_at = DateTime.current + 2
       expect(promotion.activate(@payload)).to be true
     end
 
@@ -178,28 +199,28 @@ describe Spree::Promotion, :type => :model do
     end
 
     it "should be expired if it hasn't started yet" do
-      promotion.starts_at = Time.now + 1.day
+      promotion.starts_at = Time.current + 1.day
       expect(promotion).to be_expired
     end
 
     it "should be expired if it has already ended" do
-      promotion.expires_at = Time.now - 1.day
+      promotion.expires_at = Time.current - 1.day
       expect(promotion).to be_expired
     end
 
     it "should not be expired if it has started already" do
-      promotion.starts_at = Time.now - 1.day
+      promotion.starts_at = Time.current - 1.day
       expect(promotion).not_to be_expired
     end
 
     it "should not be expired if it has not ended yet" do
-      promotion.expires_at = Time.now + 1.day
+      promotion.expires_at = Time.current + 1.day
       expect(promotion).not_to be_expired
     end
 
     it "should not be expired if current time is within starts_at and expires_at range" do
-      promotion.starts_at  = Time.now - 1.day
-      promotion.expires_at = Time.now + 1.day
+      promotion.starts_at  = Time.current - 1.day
+      promotion.expires_at = Time.current + 1.day
       expect(promotion).not_to be_expired
     end
 
@@ -297,15 +318,15 @@ describe Spree::Promotion, :type => :model do
   end
 
   context "#products" do
+    let(:product) { create(:product) }
     let(:promotion) { create(:promotion) }
 
     context "when it has product rules with products associated" do
-      let(:promotion_rule) { Spree::Promotion::Rules::Product.new }
+      let(:promotion_rule) { create(:promotion_rule, promotion: promotion, type: 'Spree::Promotion::Rules::Product') }
 
       before do
-        promotion_rule.promotion = promotion
-        promotion_rule.products << create(:product)
-        promotion_rule.save
+        promotion.promotion_rules << promotion_rule
+        product.product_promotion_rules.create(promotion_rule_id: promotion_rule.id)
       end
 
       it "should have products" do
@@ -324,7 +345,7 @@ describe Spree::Promotion, :type => :model do
     let(:promotable) { create :order }
     subject { promotion.eligible?(promotable) }
     context "when promotion is expired" do
-      before { promotion.expires_at = Time.now - 10.days }
+      before { promotion.expires_at = Time.current - 10.days }
       it { is_expected.to be false }
     end
     context "when promotable is a Spree::LineItem" do
@@ -541,8 +562,8 @@ describe Spree::Promotion, :type => :model do
     context 'when the user has used this promo' do
       before do
         promotion.activate(order: order)
-        order.update!
-        order.completed_at = Time.now
+        order.update_with_updater!
+        order.completed_at = Time.current
         order.save!
       end
 
@@ -588,7 +609,7 @@ describe Spree::Promotion, :type => :model do
       expect(order.adjustment_total).to eq 0
 
       promo.activate order: order
-      order.update!
+      order.update_with_updater!
 
       expect(line_item.adjustments.size).to eq(1)
       expect(order.adjustment_total).to eq -5

data/spec/models/spree/property_prototype_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Spree::PropertyPrototype do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:prototype) }
+    it { is_expected.to validate_presence_of(:property) }
+    it { is_expected.to validate_uniqueness_of(:prototype_id).scoped_to(:property_id).allow_nil }
+  end
+end

data/spec/models/spree/prototype_taxon_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Spree::PrototypeTaxon do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:prototype) }
+    it { is_expected.to validate_presence_of(:taxon) }
+    it { is_expected.to validate_uniqueness_of(:prototype_id).scoped_to(:taxon_id).allow_nil }
+  end
+end

data/spec/models/spree/refund_reason_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Spree::RefundReason do
+  describe 'Associations' do
+    it { is_expected.to have_many(:refunds).dependent(:restrict_with_error) }
+  end
+end

data/spec/models/spree/reimbursement_spec.rb

@@ -2,33 +2,6 @@ require 'spec_helper'
 
 describe Spree::Reimbursement, type: :model do
 
-  describe ".before_create" do
-    describe "#generate_number" do
-      context "number is assigned" do
-        let(:number)        { '123' }
-        let(:reimbursement) { Spree::Reimbursement.new(number: number) }
-
-        it "should return the assigned number" do
-          reimbursement.save
-          expect(reimbursement.number).to eq number
-        end
-      end
-
-      context "number is not assigned" do
-        let(:reimbursement) { Spree::Reimbursement.new(number: nil) }
-
-        before do
-          allow(reimbursement).to receive_messages(valid?: true)
-        end
-
-        it "should assign number with random RI number" do
-          reimbursement.save
-          expect(reimbursement.number).to be =~ /RI\d{9}/
-        end
-      end
-    end
-  end
-
   describe "#display_total" do
     let(:total)         { 100.50 }
     let(:currency)      { "USD" }
@@ -50,7 +23,7 @@ describe Spree::Reimbursement, type: :model do
     let!(:adjustments)            { [] } # placeholder to ensure it gets run prior the "before" at this level
 
     let!(:tax_rate)               { nil }
-    let!(:tax_zone)               { create(:zone, default_tax: true) }
+    let!(:tax_zone) { create(:zone_with_country, default_tax: true) }
 
     let(:order)                   { create(:order_with_line_items, state: 'payment', line_items_count: 1, line_items_price: line_items_price, shipment_cost: 0) }
     let(:line_items_price)        { BigDecimal.new(10) }
@@ -73,7 +46,7 @@ describe Spree::Reimbursement, type: :model do
         shipment.update_column('state', 'shipped')
       end
       order.reload
-      order.update!
+      order.update_with_updater!
       if payment
         payment.save!
         order.next! # confirm
@@ -118,7 +91,7 @@ describe Spree::Reimbursement, type: :model do
           subject
         }.to change { Spree::Refund.count }.by(1)
         return_item.reload
-        expect(return_item.included_tax_total).to be < 0
+        expect(return_item.included_tax_total).to be > 0
         expect(return_item.included_tax_total).to eq line_item.included_tax_total
         expect(reimbursement.total).to eq (line_item.pre_tax_amount + line_item.included_tax_total).round(2)
         expect(Spree::Refund.last.amount).to eq (line_item.pre_tax_amount + line_item.included_tax_total).round(2)

data/spec/models/spree/reimbursement_tax_calculator_spec.rb

@@ -24,8 +24,14 @@ describe Spree::ReimbursementTaxCalculator, :type => :model do
   end
 
   context 'with additional tax' do
-    let!(:tax_rate) { create(:tax_rate, name: "Sales Tax", amount: 0.10, included_in_price: false, zone: tax_zone) }
-    let(:tax_zone) { create(:zone, default_tax: true) }
+    let!(:tax_rate) do
+      create :tax_rate,
+             name: "Sales Tax",
+             amount: 0.10,
+             included_in_price: false,
+             tax_category: create(:tax_category),
+             zone: create(:zone_with_country, default_tax: true)
+    end
 
     it 'sets additional_tax_total on the return items' do
       subject
@@ -37,14 +43,20 @@ describe Spree::ReimbursementTaxCalculator, :type => :model do
   end
 
   context 'with included tax' do
-    let!(:tax_rate) { create(:tax_rate, name: "VAT Tax", amount: 0.1, included_in_price: true, zone: tax_zone) }
-    let(:tax_zone) { create(:zone, default_tax: true) }
+    let!(:tax_rate) do
+      create :tax_rate,
+             name: "VAT Tax",
+             amount: 0.10,
+             included_in_price: true,
+             tax_category: create(:tax_category),
+             zone: create(:zone_with_country, default_tax: true)
+    end
 
     it 'sets included_tax_total on the return items' do
       subject
       return_item.reload
 
-      expect(return_item.included_tax_total).to be < 0
+      expect(return_item.included_tax_total).to be > 0
       expect(return_item.included_tax_total).to eq line_item.included_tax_total
     end
   end

data/spec/models/spree/reimbursement_type/store_credit_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module Spree
+  describe ReimbursementType::StoreCredit do
+    let(:reimbursement) { create(:reimbursement, return_items_count: 2) }
+    let(:return_item) { reimbursement.return_items.first }
+    let(:return_item2) { reimbursement.return_items.last }
+    let(:payment) { reimbursement.order.payments.first }
+    let(:simulate) { false }
+    let!(:default_refund_reason) do
+      Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON,
+                                             mutable: false)
+    end
+
+    let!(:primary_credit_type) { create(:primary_credit_type) }
+    let!(:created_by_user) { create(:user, email: Spree::StoreCredit::DEFAULT_CREATED_BY_EMAIL) }
+    let!(:default_reimbursement_category) { create(:store_credit_category) }
+
+    subject do
+      Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2],
+                                                      simulate)
+    end
+
+    before { reimbursement.update!(total: reimbursement.calculated_total) }
+
+    describe '.reimburse' do
+      context 'simulate is true' do
+        let(:simulate) { true }
+
+        context 'for store credits that the customer used' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([payment])
+          end
+
+          it 'creates readonly refunds for all store credit payments' do
+            expect(subject.map(&:class)).to eq [Spree::Refund]
+            expect(subject.map(&:readonly?)).to eq [true]
+          end
+
+          it 'does not save to the database' do
+            expect { subject }.to_not change { payment.refunds.count }
+          end
+        end
+
+        context 'for return items that were not paid for with store credit' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([])
+          end
+
+          context 'creates one readonly lump credit for all outstanding balance payable to the customer' do
+            it 'creates a credit that is read only' do
+              expect(subject.map(&:class)).to eq [Spree::Reimbursement::Credit]
+              expect(subject.map(&:readonly?)).to eq [true]
+            end
+
+            it 'creates a credit which amounts to the sum of the return items rounded down' do
+              allow(return_item).to receive(:total).and_return(10.0076)
+              allow(return_item2).to receive(:total).and_return(10.0023)
+              expect(subject.sum(&:amount)).to eq 20.0
+            end
+          end
+
+          it 'does not save to the database' do
+            expect { subject }.to_not change { Spree::Reimbursement::Credit.count }
+          end
+        end
+      end
+
+      context 'simulate is false' do
+        let(:simulate) { false }
+
+        context 'for store credits that the customer used' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([payment])
+          end
+
+          it 'performs refunds for all store credit payments' do
+            expect { subject }.to change { payment.refunds.count }.by(1)
+            expect(payment.refunds.sum(:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+          end
+        end
+
+        context 'for return items that were not paid for with store credit' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([])
+          end
+
+          it 'creates one lump credit for all outstanding balance payable to the customer' do
+            expect { subject }.to change { Spree::Reimbursement::Credit.count }.by(1)
+            expect(subject.sum(&:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+          end
+
+          it "creates a store credit with the same currency as the reimbursement's order" do
+            expect { subject }.to change { Spree::StoreCredit.count }.by(1)
+            expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
+          end
+        end
+      end
+    end
+  end
+end