spree_core 3.0.10 → 3.1.0.rc1

data/spec/models/spree/payment_method_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe Spree::PaymentMethod, type: :model do
-  describe "#available" do
+  context "visibility scopes" do
     before do
-      [nil, 'both', 'front_end', 'back_end'].each do |display_on|
+      [nil, '', 'both', 'front_end', 'back_end'].each do |display_on|
         Spree::Gateway::Test.create(
           name: 'Display Both',
           display_on: display_on,
@@ -13,24 +13,32 @@ describe Spree::PaymentMethod, type: :model do
       end
     end
 
-    it "should have 4 total methods" do
-      expect(Spree::PaymentMethod.all.size).to eq(4)
+    it "should have 5 total methods" do
+      expect(Spree::PaymentMethod.count).to eq(5)
     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)
-    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)
+    describe "#available" do
+      it "should return all methods available to front-end/back-end" do
+        methods = Spree::PaymentMethod.available
+        expect(methods.size).to eq(3)
+        expect(methods.pluck(:display_on)).to eq(['both', 'front_end', 'back_end'])
+      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)
+    describe "#available_on_front_end" do
+      it "should return all methods available to front-end" do
+        methods = Spree::PaymentMethod.available_on_front_end
+        expect(methods.size).to eq(2)
+        expect(methods.pluck(:display_on)).to eq(['both', 'front_end'])
+      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)
+    describe "#available_on_back_end" do
+      it "should return all methods available to back-end" do
+        methods = Spree::PaymentMethod.available_on_back_end
+        expect(methods.size).to eq(2)
+        expect(methods.pluck(:display_on)).to eq(['both', 'back_end'])
+      end
     end
   end
 

data/spec/models/spree/payment_spec.rb

@@ -5,8 +5,8 @@ describe Spree::Payment, :type => :model do
   let(:refund_reason) { create(:refund_reason) }
 
   let(:gateway) do
-    gateway = Spree::Gateway::Bogus.create(active: true, name: 'Bogus')
-    allow(gateway).to receive_messages source_required: true
+    gateway = Spree::Gateway::Bogus.new(:active => true)
+    allow(gateway).to receive_messages :source_required => true
     gateway
   end
 
@@ -43,6 +43,41 @@ describe Spree::Payment, :type => :model do
     allow(payment.log_entries).to receive(:create!)
   end
 
+  describe 'delegate' do
+    it { is_expected.to delegate_method(:currency).to(:order) }
+  end
+
+  describe 'Constants' do
+    it { expect(Spree::Payment::INVALID_STATES).to eq(%w(failed invalid)) }
+  end
+
+  describe 'scopes' do
+    describe '.valid' do
+      let!(:invalid_payment) do
+        create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: '', state: 'invalid')
+      end
+
+      let!(:failed_payment) do
+        create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: '', state: 'failed')
+      end
+
+      let!(:checkout_payment) do
+        create(:payment, avs_response: 'A', cvv_response_code: 'M', cvv_response_message: '', state: 'checkout')
+      end
+
+      let!(:completed_payment) do
+        create(:payment, avs_response: 'Y', cvv_response_code: 'N', cvv_response_message: '', state: 'completed')
+      end
+
+      subject { Spree::Payment.valid }
+
+      it { is_expected.to_not include(invalid_payment) }
+      it { is_expected.to_not include(failed_payment) }
+      it { is_expected.to     include(checkout_payment) }
+      it { is_expected.to     include(completed_payment) }
+    end
+  end
+
   context '.risky' do
 
     let!(:payment_1) { create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: 'Match') }
@@ -664,48 +699,6 @@ describe Spree::Payment, :type => :model do
     end
   end
 
-  describe "#set_unique_number" do
-    # Regression test for #1998
-    it "sets a unique number on create" do
-      payment.generate_number
-      payment.save
-
-      expect(payment.number).to_not be_blank
-      expect(payment.number.length).to eq 8
-      expect(payment.number).to be_a(String)
-    end
-
-    # Regression test for #3733
-    it "does not regenerate the number on re-save" do
-      payment.run_callbacks(:create)
-      payment.save
-      old_number = payment.number
-      payment.save
-      expect(payment.number).to eq old_number
-    end
-
-    context "other payment exists" do
-      let(:other_payment) {
-        payment = Spree::Payment.new
-        payment.source = card
-        payment.order = order
-        payment.payment_method = gateway
-        payment
-      }
-
-      it "doesn't set duplicate number" do
-        other_payment.run_callbacks(:create)
-        other_payment.save!
-
-        payment.run_callbacks(:create)
-        payment.save!
-
-        expect(payment.number).to_not be_blank
-        expect(payment.number).to_not eq other_payment.number
-      end
-    end
-  end
-
   describe "#amount=" do
     before do
       subject.amount = amount

data/spec/models/spree/price_spec.rb

@@ -1,6 +1,34 @@
 require 'spec_helper'
 
 describe Spree::Price, :type => :model do
+  describe '#amount=' do
+    let(:price) { Spree::Price.new }
+    let(:amount) { '3,0A0' }
+
+    before do
+      price.amount = amount
+    end
+
+    it 'is expected to equal to localized number' do
+      expect(price.amount).to eq(Spree::LocalizedNumber.parse(amount))
+    end
+  end
+
+  describe '#price' do
+    let(:price) { Spree::Price.new }
+    let(:amount) { 3000.00 }
+
+    context 'when amount is changed' do
+      before do
+        price.amount = amount
+      end
+
+      it 'is expected to equal to price' do
+        expect(price.amount).to eq(price.price)
+      end
+    end
+  end
+
   describe 'validations' do
     let(:variant) { stub_model Spree::Variant }
     subject { Spree::Price.new variant: variant, amount: amount }
@@ -39,4 +67,62 @@ describe Spree::Price, :type => :model do
       it { is_expected.to be_valid }
     end
   end
+
+  describe '#price_including_vat_for(zone)' do
+    let(:variant) { stub_model Spree::Variant }
+    let(:default_zone) { Spree::Zone.new }
+    let(:zone) { Spree::Zone.new }
+    let(:amount) { 10 }
+    let(:tax_category) { Spree::TaxCategory.new }
+    let(:price) { Spree::Price.new variant: variant, amount: amount }
+    let(:price_options) { { tax_zone: zone } }
+
+    subject(:price_with_vat) { price.price_including_vat_for(price_options) }
+
+    context 'when called with a non-default zone' do
+      before do
+        allow(variant).to receive(:tax_category).and_return(tax_category)
+        expect(price).to receive(:default_zone).at_least(:once).and_return(default_zone)
+        allow(price).to receive(:apply_foreign_vat?).and_return(true)
+        allow(price).to receive(:included_tax_amount).with(tax_zone: default_zone, tax_category: tax_category) { 0.19 }
+        allow(price).to receive(:included_tax_amount).with(tax_zone: zone, tax_category: tax_category) { 0.25 }
+      end
+
+      it "returns the correct price including another VAT to two digits" do
+        expect(price_with_vat).to eq(10.50)
+      end
+    end
+
+    context 'when called from the default zone' do
+      before do
+        allow(variant).to receive(:tax_category).and_return(tax_category)
+        expect(price).to receive(:default_zone).at_least(:once).and_return(zone)
+      end
+
+      it "returns the correct price" do
+        expect(price).to receive(:price).and_call_original
+        expect(price_with_vat).to eq(10.00)
+      end
+    end
+
+    context 'when no default zone is set' do
+      before do
+        allow(variant).to receive(:tax_category).and_return(tax_category)
+        expect(price).to receive(:default_zone).at_least(:once).and_return(nil)
+      end
+
+      it "returns the correct price" do
+        expect(price).to receive(:price).and_call_original
+        expect(price.price_including_vat_for(tax_zone: zone)).to eq(10.00)
+      end
+    end
+  end
+
+  describe '#display_price_including_vat_for(zone)' do
+    subject { Spree::Price.new amount: 10 }
+    it 'calls #price_including_vat_for' do
+      expect(subject).to receive(:price_including_vat_for)
+      subject.display_price_including_vat_for(nil)
+    end
+  end
 end

data/spec/models/spree/product/scopes_spec.rb

@@ -3,6 +3,41 @@ require 'spec_helper'
 describe "Product scopes", :type => :model do
   let!(:product) { create(:product) }
 
+  describe '#available' do
+    context 'when discontinued' do
+      let!(:discontinued_product) { create(:product, discontinue_on: Time.current - 1.day) }
+
+      it { expect(Spree::Product.available).not_to include(discontinued_product) }
+    end
+
+    context 'when not discontinued' do
+      let!(:product_2) { create(:product, discontinue_on: Time.current + 1.day) }
+
+      it { expect(Spree::Product.available).to include(product_2) }
+    end
+
+    context 'when available' do
+      let!(:product_2) { create(:product, available_on: Time.current - 1.day) }
+
+      it { expect(Spree::Product.available).to include(product_2) }
+    end
+
+    context 'when not available' do
+      let!(:unavailable_product) { create(:product, available_on: Time.current + 1.day) }
+
+      it { expect(Spree::Product.available).not_to include(unavailable_product) }
+    end
+
+    context 'when multiple prices present' do
+      let!(:price_1) { create(:price, currency: 'EUR', variant: product.master) }
+      let!(:price_2) { create(:price, currency: 'EUR', variant: product.master) }
+
+      it 'should not duplicate product' do
+        expect(Spree::Product.available).to eq([product])
+      end
+    end
+  end
+
   context "A product assigned to parent and child taxons" do
     before do
       @taxonomy = create(:taxonomy)

data/spec/models/spree/product_option_type_spec.rb

@@ -1,5 +1,9 @@
 require 'spec_helper'
 
-describe Spree::ProductOptionType, :type => :model do
-
+describe Spree::ProductOptionType do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:product) }
+    it { is_expected.to validate_presence_of(:option_type) }
+    it { is_expected.to validate_uniqueness_of(:product_id).scoped_to(:option_type_id).allow_nil }
+  end
 end

data/spec/models/spree/product_promotion_rule_spec.rb

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

data/spec/models/spree/product_property_spec.rb

@@ -8,4 +8,15 @@ describe Spree::ProductProperty, :type => :model do
       pp.touch
     end
   end
+
+  context 'property_name=' do
+    before do
+      @pp = create(:product_property)
+    end
+
+    it "should assign property" do
+      @pp.property_name = "Size"
+      expect(@pp.property.name).to eq('Size')
+    end
+  end
 end

data/spec/models/spree/product_spec.rb

@@ -11,6 +11,18 @@ end
 
 describe Spree::Product, :type => :model do
 
+  describe 'Associations' do
+    it 'should have many promotions' do
+      is_expected.to have_many(:promotions).
+        class_name('Spree::Promotion').through(:promotion_rules)
+    end
+
+    it 'should have many possible_promotions' do
+      is_expected.to have_many(:possible_promotions).
+        class_name('Spree::Promotion').through(:promotion_rules).source(:promotion)
+    end
+  end
+
   context 'product instance' do
     let(:product) { create(:product) }
     let(:variant) { create(:variant, :product => product) }
@@ -148,6 +160,17 @@ describe Spree::Product, :type => :model do
       end
     end
 
+    context "#can_supply?" do
+      it "should be true" do
+        expect(product.can_supply?).to be(true)
+      end
+
+      it "should be false" do
+        product.variants_including_master.each { |v| v.stock_items.update_all count_on_hand: 0, backorderable: false }
+        expect(product.can_supply?).to be(false)
+      end
+    end
+
     context "variants_and_option_values" do
       let!(:high) { create(:variant, product: product) }
       let!(:low) { create(:variant, product: product) }
@@ -160,15 +183,17 @@ describe Spree::Product, :type => :model do
     end
 
     describe 'Variants sorting' do
+      ORDER_REGEXP = /ORDER BY (\`|\")spree_variants(\`|\").(\'|\")position(\'|\") ASC/
+
       context 'without master variant' do
         it 'sorts variants by position' do
-          expect(product.variants.to_sql).to match(/ORDER BY (\`|\")spree_variants(\`|\").position ASC/)
+          expect(product.variants.to_sql).to match(ORDER_REGEXP)
         end
       end
 
       context 'with master variant' do
         it 'sorts variants by position' do
-          expect(product.variants_including_master.to_sql).to match(/ORDER BY (\`|\")spree_variants(\`|\").position ASC/)
+          expect(product.variants_including_master.to_sql).to match(ORDER_REGEXP)
         end
       end
     end
@@ -298,6 +323,22 @@ describe Spree::Product, :type => :model do
       }.to change { product.properties.length }.by(1)
     end
 
+    context 'optional property_presentation' do
+      subject { Spree::Property.where(name: 'foo').first.presentation }
+      let(:name) { 'foo' }
+      let(:presentation) { 'baz' }
+
+      describe 'is not used' do
+        before { product.set_property(name, 'bar') }
+        it { is_expected.to eq name }
+      end
+
+      describe 'is used' do
+        before { product.set_property(name, 'bar', presentation) }
+        it { is_expected.to eq presentation }
+      end
+    end
+
     # Regression test for #2455
     it "should not overwrite properties' presentation names" do
       Spree::Property.where(:name => 'foo').first_or_create!(:presentation => "Foo's Presentation Name")
@@ -309,18 +350,20 @@ describe Spree::Product, :type => :model do
 
     # Regression test for #4416
     context "#possible_promotions" do
-      let!(:promotion) do
-        create(:promotion, advertise: true, starts_at: 1.day.ago)
-      end
-      let!(:rule) do
-        Spree::Promotion::Rules::Product.create(
-          promotion: promotion,
-          products: [product]
-        )
+      let!(:possible_promotion) { create(:promotion, advertise: true, starts_at: 1.day.ago) }
+      let!(:unadvertised_promotion) { create(:promotion, advertise: false, starts_at: 1.day.ago) }
+      let!(:inactive_promotion) { create(:promotion, advertise: true, starts_at: 1.day.since) }
+
+      before do
+        product.promotion_rules.create!(promotion: possible_promotion)
+        product.promotion_rules.create!(promotion: unadvertised_promotion)
+        product.promotion_rules.create!(promotion: inactive_promotion)
       end
 
       it "lists the promotion as a possible promotion" do
-        expect(product.possible_promotions).to include(promotion)
+        expect(product.possible_promotions).to include(possible_promotion)
+        expect(product.possible_promotions).to_not include(unadvertised_promotion)
+        expect(product.possible_promotions).to_not include(inactive_promotion)
       end
     end
   end
@@ -340,11 +383,9 @@ describe Spree::Product, :type => :model do
 
     context "when prototype with option types is supplied" do
       def build_option_type_with_values(name, values)
-        ot = create(:option_type, :name => name)
-        values.each do |val|
-          ot.option_values.create(:name => val.downcase, :presentation => val)
+        values.each_with_object(create :option_type, name: name) do |val, ot|
+          ot.option_values.create(name: val.downcase, presentation: val)
         end
-        ot
       end
 
       let(:prototype) do
@@ -471,4 +512,30 @@ describe Spree::Product, :type => :model do
     product = Spree::Product.new
     expect(product.master.is_master).to be true
   end
+
+  context "#discontinue!" do
+    let(:product) { create(:product, sku: 'a-sku') }
+
+    it "sets the discontinued" do
+      product.discontinue!
+      product.reload
+      expect(product.discontinued?).to be(true)
+    end
+
+    it "changes updated_at" do
+      expect { product.discontinue! }.to change { product.updated_at }
+    end
+  end
+
+  context "#discontinued?" do
+    let(:product_live) { build(:product, sku: "a-sku") }
+    it "should be false" do
+      expect(product_live.discontinued?).to be(false)
+    end
+
+    let(:product_discontinued) { build(:product, sku: "a-sku", discontinue_on: Time.now - 1.day)  }
+    it "should be true" do
+      expect(product_discontinued.discontinued?).to be(true)
+    end
+  end
 end