spree_core 3.0.9 → 3.2.0

data/spec/models/spree/promotion_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Spree::Promotion, :type => :model do
+describe Spree::Promotion, type: :model do
   let(:promotion) { Spree::Promotion.new }
 
   describe "validations" do
     before :each do
-      @valid_promotion = Spree::Promotion.new :name => "A promotion"
+      @valid_promotion = Spree::Promotion.new name: "A promotion"
     end
 
     it "valid_promotion is valid" do
@@ -24,41 +24,97 @@ describe Spree::Promotion, :type => :model do
       @valid_promotion.name = nil
       expect(@valid_promotion).not_to be_valid
     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 "expires_at_must_be_later_than_starts_at" do
+      before do
+        @valid_promotion.starts_at = Date.today
+      end
+
+      context "starts_at is a date earlier than expires_at" do
+        before { @valid_promotion.expires_at = 5.days.from_now }
+
+        it "is valid" do
+          expect(@valid_promotion).to be_valid
+        end
+      end
+
+      context "starts_at is a date earlier than expires_at" do
+        before { @valid_promotion.expires_at = 5.days.ago }
+
+        context "is not valid" do
+          before { @valid_promotion.valid? }
+          it { expect(@valid_promotion).not_to be_valid }
+          it { expect(@valid_promotion.errors[:expires_at]).to include(I18n.t(:invalid_date_range, scope: 'activerecord.errors.models.spree/promotion.attributes.expires_at')) }
+        end
+      end
+
+      context "starts_at and expires_at are nil" do
+        before do
+          @valid_promotion.expires_at = nil
+          @valid_promotion.starts_at = nil
+        end
 
-      promotion.update_column :code, "check"
-      expect(Spree::Promotion.coupons.first).to eq promotion
+        it "is valid" do
+          expect(@valid_promotion).to be_valid
+        end
+      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 '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' }
+
+      subject { Spree::Promotion.coupons }
 
-      promotion.orders << create(:order)
-      expect(Spree::Promotion.applied.first).to eq promotion
+      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 ".advertised" do
-    let(:promotion) { create(:promotion) }
-    let(:advertised_promotion) { create(:promotion, :advertise => true) }
+    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
+
+      it 'is expected to include promotion applied' do
+        is_expected.to include(promotion_applied)
+      end
+    end
+
+    describe '.advertised' do
+      let!(:promotion_not_advertised) { Spree::Promotion.create! name: 'test', advertise: false }
+      let!(:promotion_advertised) { Spree::Promotion.create! name: 'test1', advertise: true }
+
+      subject { Spree::Promotion.advertised }
+
+      it 'is expected to not include promotion not advertised' do
+        is_expected.to_not include(promotion_not_advertised)
+      end
 
-    it "only shows advertised promotions" do
-      advertised = Spree::Promotion.advertised
-      expect(advertised).to include(advertised_promotion)
-      expect(advertised).not_to include(promotion)
+      it 'is expected to include promotion advertised' do
+        is_expected.to include(promotion_advertised)
+      end
     end
   end
 
   describe "#destroy" do
-    let(:promotion) { Spree::Promotion.create(:name => "delete me") }
+    let(:promotion) { Spree::Promotion.create(name: "delete me") }
 
     before(:each) do
       promotion.actions << Spree::Promotion::Actions::CreateAdjustment.new
@@ -77,7 +133,7 @@ describe Spree::Promotion, :type => :model do
   end
 
   describe "#save" do
-    let(:promotion) { Spree::Promotion.create(:name => "delete me") }
+    let(:promotion) { Spree::Promotion.create(name: "delete me") }
 
     before(:each) do
       promotion.actions << Spree::Promotion::Actions::CreateAdjustment.new
@@ -102,9 +158,9 @@ describe Spree::Promotion, :type => :model do
       promotion.promotion_actions = [@action1, @action2]
       promotion.created_at = 2.days.ago
 
-      @user = stub_model(Spree::LegacyUser, :email => "spree@example.com")
+      @user = stub_model(Spree::LegacyUser, email: "spree@example.com")
       @order = Spree::Order.create user: @user
-      @payload = { :order => @order, :user => @user }
+      @payload = { order: @order, user: @user }
     end
 
     it "should check path if present" do
@@ -130,7 +186,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
 
@@ -164,10 +220,10 @@ describe Spree::Promotion, :type => :model do
 
     it "should have its usage limit exceeded" do
       promotion.usage_limit = 2
-      allow(promotion).to receive_messages(:adjusted_credits_count => 2)
+      allow(promotion).to receive_messages(adjusted_credits_count: 2)
       expect(promotion.usage_limit_exceeded?(promotable)).to be true
 
-      allow(promotion).to receive_messages(:adjusted_credits_count => 3)
+      allow(promotion).to receive_messages(adjusted_credits_count: 3)
       expect(promotion.usage_limit_exceeded?(promotable)).to be true
     end
   end
@@ -178,34 +234,34 @@ 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
 
     it "should not be expired if usage limit is not exceeded" do
       promotion.usage_limit = 2
-      allow(promotion).to receive_messages(:credits_count => 1)
+      allow(promotion).to receive_messages(credits_count: 1)
       expect(promotion).not_to be_expired
     end
   end
@@ -221,7 +277,7 @@ describe Spree::Promotion, :type => :model do
 
     let!(:action) do
       calculator = Spree::Calculator::FlatRate.new
-      action_params = { :promotion => promotion, :calculator => calculator }
+      action_params = { promotion: promotion, calculator: calculator }
       action = Spree::Promotion::Actions::CreateAdjustment.create(action_params)
       promotion.actions << action
       action
@@ -253,7 +309,7 @@ describe Spree::Promotion, :type => :model do
   context "#adjusted_credits_count" do
     let(:order) { create :order }
     let(:line_item) { create :line_item, order: order }
-    let(:promotion) { Spree::Promotion.create name: "promo", :code => "10off" }
+    let(:promotion) { Spree::Promotion.create name: "promo", code: "10off" }
     let(:order_action) {
       action = Spree::Promotion::Actions::CreateAdjustment.create(calculator: Spree::Calculator::FlatPercentItemTotal.new)
       promotion.actions << action
@@ -266,20 +322,20 @@ describe Spree::Promotion, :type => :model do
     }
     let(:order_adjustment) do
       Spree::Adjustment.create!(
-        :source => order_action,
-        :amount => 10,
-        :adjustable => order,
-        :order => order,
-        :label => "Promotional adjustment"
+        source: order_action,
+        amount: 10,
+        adjustable: order,
+        order: order,
+        label: "Promotional adjustment"
       )
     end
     let(:item_adjustment) do
       Spree::Adjustment.create!(
-        :source => item_action,
-        :amount => 10,
-        :adjustable => line_item,
-        :order => order,
-        :label => "Promotional adjustment"
+        source: item_action,
+        amount: 10,
+        adjustable: line_item,
+        order: order,
+        label: "Promotional adjustment"
       )
     end
 
@@ -297,15 +353,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 +380,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
@@ -369,7 +425,7 @@ describe Spree::Promotion, :type => :model do
     end
 
     it "true if there are no applicable rules" do
-      promotion.promotion_rules = [stub_model(Spree::PromotionRule, :eligible? => true, :applicable? => false)]
+      promotion.promotion_rules = [stub_model(Spree::PromotionRule, eligible?: true, applicable?: false)]
       allow(promotion.promotion_rules).to receive(:for).and_return([])
       expect(promotion.eligible_rules(promotable)).to eq []
     end
@@ -417,14 +473,14 @@ describe Spree::Promotion, :type => :model do
     end
 
     context "with 'any' match policy" do
-      let(:promotion) { Spree::Promotion.create(:name => "Promo", :match_policy => 'any') }
+      let(:promotion) { Spree::Promotion.create(name: "Promo", match_policy: 'any') }
       let(:promotable) { double('Promotable') }
 
       it "should have eligible rules if any of the rules are eligible" do
-        allow_any_instance_of(Spree::PromotionRule).to receive_messages(:applicable? => true)
-        true_rule = Spree::PromotionRule.create(:promotion => promotion)
-        allow(true_rule).to receive_messages(:eligible? => true)
-        allow(promotion).to receive_messages(:rules => [true_rule])
+        allow_any_instance_of(Spree::PromotionRule).to receive_messages(applicable?: true)
+        true_rule = Spree::PromotionRule.create(promotion: promotion)
+        allow(true_rule).to receive_messages(eligible?: true)
+        allow(promotion).to receive_messages(rules: [true_rule])
         allow(promotion).to receive_message_chain(:rules, :for).and_return([true_rule])
         expect(promotion.eligible_rules(promotable)).to eq [true_rule]
       end
@@ -509,7 +565,7 @@ describe Spree::Promotion, :type => :model do
   # admin form posts the code and path as empty string
   describe "normalize blank values for code & path" do
     it "will save blank value as nil value instead" do
-      promotion = Spree::Promotion.create(:name => "A promotion", :code => "", :path => "")
+      promotion = Spree::Promotion.create(name: "A promotion", code: "", path: "")
       expect(promotion.code).to be_nil
       expect(promotion.path).to be_nil
     end
@@ -518,11 +574,31 @@ describe Spree::Promotion, :type => :model do
   # Regression test for #4081
   describe "#with_coupon_code" do
     context "and code stored in uppercase" do
-      let!(:promotion) { create(:promotion, :code => "MY-COUPON-123") }
+      let!(:promotion) { create(:promotion, :with_order_adjustment, code: "MY-COUPON-123") }
       it "finds the code with lowercase" do
         expect(Spree::Promotion.with_coupon_code("my-coupon-123")).to eql promotion
       end
     end
+
+    context "and there are multiple coupons with the same code" do
+      context "and only one has any actions" do
+        let!(:promotion_without_actions) { create(:promotion, code: "MY-COUPON-123").actions.clear }
+        let!(:promotion) { create(:promotion, :with_order_adjustment, code: "MY-COUPON-123") }
+
+        it "then returns the one with an action" do
+          expect(Spree::Promotion.with_coupon_code("MY-COUPON-123").actions.exists?).to be
+        end
+      end
+
+      context "and all of them has actions" do
+        let!(:first_promotion) { create(:promotion, :with_order_adjustment, code: "MY-COUPON-123") }
+        let!(:second_promotion) { create(:promotion, :with_order_adjustment, code: "MY-COUPON-123") }
+
+        it "then returns the first one with an action" do
+          expect(Spree::Promotion.with_coupon_code("MY-COUPON-123").id).to eq(first_promotion.id)
+        end
+      end
+    end
   end
 
   describe '#used_by?' do
@@ -541,8 +617,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 +664,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/property_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe Spree::Property, :type => :model do
+describe Spree::Property, type: :model do
 
 end

data/spec/models/spree/prototype_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe Spree::Prototype, :type => :model do
+describe Spree::Prototype, type: :model do
 
 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,20 @@
+require 'spec_helper'
+
+describe Spree::RefundReason do
+  describe 'Associations' do
+    it { is_expected.to have_many(:refunds).dependent(:restrict_with_error) }
+  end
+
+  describe 'Class Methods' do
+    describe '.return_processing_reason' do
+      context 'default refund reason present' do
+        let!(:default_refund_reason) { create(:default_refund_reason) }
+        it { expect(described_class.return_processing_reason).to eq(default_refund_reason) }
+      end
+
+      context 'default refund reason not present' do
+        it { expect(described_class.return_processing_reason).to eq(nil) }
+      end
+    end
+  end
+end

data/spec/models/spree/refund_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Refund, :type => :model do
+describe Spree::Refund, type: :model do
 
   describe 'create' do
     let(:amount) { 100.0 }

data/spec/models/spree/reimbursement/credit_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Reimbursement::Credit, :type => :model do
+  describe Reimbursement::Credit, type: :model do
     context 'class methods' do
       describe '.total_amount_reimbursed_for' do
         subject { Spree::Reimbursement::Credit.total_amount_reimbursed_for(reimbursement) }

data/spec/models/spree/reimbursement/reimbursement_type_engine_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Reimbursement::ReimbursementTypeEngine, :type => :model do
+  describe Reimbursement::ReimbursementTypeEngine, type: :model do
     describe '#calculate_reimbursement_types' do
       let(:return_item)   { create(:return_item) }
       let(:return_items)  { [ return_item ] }

data/spec/models/spree/reimbursement/reimbursement_type_validator_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Reimbursement::ReimbursementTypeValidator, :type => :model do
+  describe Reimbursement::ReimbursementTypeValidator, type: :model do
     class DummyClass
       include Spree::Reimbursement::ReimbursementTypeValidator
 

data/spec/models/spree/reimbursement_performer_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReimbursementPerformer, :type => :model do
+describe Spree::ReimbursementPerformer, type: :model do
   let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
   let(:return_item)             { reimbursement.return_items.first }
   let(:reimbursement_type)      { double("ReimbursementType") }

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReimbursementTaxCalculator, :type => :model do
+describe Spree::ReimbursementTaxCalculator, type: :model do
 
   let!(:tax_rate) { nil }
 
@@ -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/credit_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe ReimbursementType::Credit, :type => :model do
+  describe ReimbursementType::Credit, type: :model do
     let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
     let(:return_item)             { reimbursement.return_items.first }
     let(:payment)                 { reimbursement.order.payments.first }

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe ReimbursementType::Exchange, :type => :model do
+  describe ReimbursementType::Exchange, type: :model do
     describe '.reimburse' do
       let(:reimbursement) { create(:reimbursement, return_items_count: 1) }
       let(:return_items)  { reimbursement.return_items }

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe ReimbursementType::OriginalPayment, :type => :model do
+  describe ReimbursementType::OriginalPayment, type: :model do
     let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
     let(:return_item)             { reimbursement.return_items.first }
     let(:payment)                 { reimbursement.order.payments.first }