spree_core 3.1.5 → 3.1.6

data/spec/models/spree/preferences/scoped_store_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Preferences::ScopedStore, :type => :model do
-  let(:scoped_store){ described_class.new(prefix, suffix) }
-  subject{ scoped_store }
-  let(:prefix){ nil }
-  let(:suffix){ nil }
-
-  describe '#store' do
-    subject{ scoped_store.store }
-    it{ is_expected.to be Spree::Preferences::Store.instance }
-  end
-
-  context 'stubbed store' do
-    let(:store){ double(:store) }
-    before do
-      allow(scoped_store).to receive(:store).and_return(store)
-    end
-
-    context "with a prefix" do
-      let(:prefix){ 'my_class' }
-
-      it "can fetch" do
-        expect(store).to receive(:fetch).with('my_class/attr')
-        scoped_store.fetch('attr'){ 'default' }
-      end
-
-      it "can assign" do
-        expect(store).to receive(:[]=).with('my_class/attr', 'val')
-        scoped_store['attr'] = 'val'
-      end
-
-      it "can delete" do
-        expect(store).to receive(:delete).with('my_class/attr')
-        scoped_store.delete('attr')
-      end
-
-      context "and suffix" do
-        let(:suffix){ 123 }
-
-        it "can fetch" do
-          expect(store).to receive(:fetch).with('my_class/attr/123')
-          scoped_store.fetch('attr'){ 'default' }
-        end
-
-        it "can assign" do
-          expect(store).to receive(:[]=).with('my_class/attr/123', 'val')
-          scoped_store['attr'] = 'val'
-        end
-
-        it "can delete" do
-          expect(store).to receive(:delete).with('my_class/attr/123')
-          scoped_store.delete('attr')
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/preferences/store_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Preferences::Store, :type => :model do
-  before :each do
-    @store = Spree::Preferences::StoreInstance.new
-  end
-
-  it "sets and gets a key" do
-    @store.set :test, 1
-    expect(@store.exist?(:test)).to be true
-    expect(@store.get(:test)).to eq 1
-  end
-
-  it "can set and get false values when cache return nil" do
-    @store.set :test, false
-    expect(@store.get(:test)).to be false
-  end
-
-  it "will return db value when cache is emtpy and cache the db value" do
-    preference = Spree::Preference.where(:key => 'test').first_or_initialize
-    preference.value = '123'
-    preference.save
-
-    Rails.cache.clear
-    expect(@store.get(:test)).to eq '123'
-    expect(Rails.cache.read(:test)).to eq '123'
-  end
-
-  it "should return and cache fallback value when supplied" do
-    Rails.cache.clear
-    expect(@store.get(:test){ false }).to be false
-    expect(Rails.cache.read(:test)).to be false
-  end
-
-  it "should return but not cache fallback value when persistence is disabled" do
-    Rails.cache.clear
-    allow(@store).to receive_messages(:should_persist? => false)
-    expect(@store.get(:test){ true }).to be true
-    expect(Rails.cache.exist?(:test)).to be false
-  end
-
-  it "should return nil when key can't be found and fallback value is not supplied" do
-    expect(@store.get(:random_key){ nil }).to be_nil
-  end
-
-end

data/spec/models/spree/price_spec.rb

@@ -1,128 +0,0 @@
-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 }
-
-    context 'when the amount is nil' do
-      let(:amount) { nil }
-      it { is_expected.to be_valid }
-    end
-
-    context 'when the amount is less than 0' do
-      let(:amount) { -1 }
-
-      it 'has 1 error_on' do
-        expect(subject.error_on(:amount).size).to eq(1)
-      end
-      it 'populates errors' do
-        subject.valid?
-        expect(subject.errors.messages[:amount].first).to eq 'must be greater than or equal to 0'
-      end
-    end
-
-    context 'when the amount is greater than maximum amount' do
-      let(:amount) { Spree::Price::MAXIMUM_AMOUNT + 1 }
-
-      it 'has 1 error_on' do
-        expect(subject.error_on(:amount).size).to eq(1)
-      end
-      it 'populates errors' do
-        subject.valid?
-        expect(subject.errors.messages[:amount].first).to eq "must be less than or equal to #{Spree::Price::MAXIMUM_AMOUNT}"
-      end
-    end
-
-    context 'when the amount is between 0 and the maximum amount' do
-      let(:amount) { Spree::Price::MAXIMUM_AMOUNT }
-      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

@@ -1,183 +0,0 @@
-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)
-      @root_taxon = @taxonomy.root
-
-      @parent_taxon = create(:taxon, :name => 'Parent', :taxonomy_id => @taxonomy.id, :parent => @root_taxon)
-      @child_taxon = create(:taxon, :name =>'Child 1', :taxonomy_id => @taxonomy.id, :parent => @parent_taxon)
-      @parent_taxon.reload # Need to reload for descendents to show up
-
-      product.taxons << @parent_taxon
-      product.taxons << @child_taxon
-    end
-
-    it "calling Product.in_taxon returns products in child taxons" do
-      product.taxons -= [@child_taxon]
-      expect(product.taxons.count).to eq(1)
-
-      expect(Spree::Product.in_taxon(@parent_taxon)).to include(product)
-    end
-
-    it "calling Product.in_taxon should not return duplicate records" do
-      expect(Spree::Product.in_taxon(@parent_taxon).to_a.count).to eq(1)
-    end
-
-    context 'orders products based on their ordering within the classifications' do
-      let(:other_taxon) { create(:taxon, products: [product]) }
-      let!(:product_2) { create(:product, taxons: [@child_taxon, other_taxon]) }
-
-      it 'by initial ordering' do
-        expect(Spree::Product.in_taxon(@child_taxon)).to eq([product, product_2])
-        expect(Spree::Product.in_taxon(other_taxon)).to eq([product, product_2])
-      end
-
-      it 'after ordering changed' do
-        [@child_taxon, other_taxon].each do |taxon|
-          Spree::Classification.find_by(:taxon => taxon, :product => product).insert_at(2)
-          expect(Spree::Product.in_taxon(taxon)).to eq([product_2, product])
-        end
-      end
-    end
-  end
-
-  context "property scopes" do
-    let(:name) { "A proper tee" }
-    let(:value) { "A proper value"}
-    let!(:property) { create(:property, name: name)}
-
-    before do
-      product.properties << property
-      product.product_properties.find_by(property: property).update_column(:value, value)
-    end
-
-    context "with_property" do
-      let(:with_property) { Spree::Product.method(:with_property) }
-      it "finds by a property's name" do
-        expect(with_property.(name).count).to eq(1)
-      end
-
-      it "doesn't find any properties with an unknown name" do
-        expect(with_property.("fake").count).to eq(0)
-      end
-
-      it "finds by a property" do
-        expect(with_property.(property).count).to eq(1)
-      end
-
-      it "finds by an id" do
-        expect(with_property.(property.id).count).to eq(1)
-      end
-
-      it "cannot find a property with an unknown id" do
-        expect(with_property.(0).count).to eq(0)
-      end
-    end
-
-    context "with_property_value" do
-      let(:with_property_value) { Spree::Product.method(:with_property_value) }
-      it "finds by a property's name" do
-        expect(with_property_value.(name, value).count).to eq(1)
-      end
-
-      it "cannot find by an unknown property's name" do
-        expect(with_property_value.("fake", value).count).to eq(0)
-      end
-
-      it "cannot find with a name by an incorrect value" do
-        expect(with_property_value.(name, "fake").count).to eq(0)
-      end
-
-      it "finds by a property" do
-        expect(with_property_value.(property, value).count).to eq(1)
-      end
-
-      it "cannot find with a property by an incorrect value" do
-        expect(with_property_value.(property, "fake").count).to eq(0)
-      end
-
-      it "finds by an id with a value" do
-        expect(with_property_value.(property.id, value).count).to eq(1)
-      end
-
-      it "cannot find with an invalid id" do
-        expect(with_property_value.(0, value).count).to eq(0)
-      end
-
-      it "cannot find with an invalid value" do
-        expect(with_property_value.(property.id, "fake").count).to eq(0)
-      end
-    end
-  end
-
-  context '#add_simple_scopes' do
-    let(:simple_scopes) { [:ascend_by_updated_at, :descend_by_name] }
-
-    before do
-      Spree::Product.add_simple_scopes(simple_scopes)
-    end
-
-    context 'define scope' do
-      context 'ascend_by_updated_at' do
-        context 'on class' do
-          it { expect(Spree::Product.ascend_by_updated_at.to_sql).to eq Spree::Product.order("#{Spree::Product.quoted_table_name}.updated_at ASC").to_sql }
-        end
-
-        context 'on ActiveRecord::Relation' do
-          it { expect(Spree::Product.limit(2).ascend_by_updated_at.to_sql).to eq Spree::Product.limit(2).order("#{Spree::Product.quoted_table_name}.updated_at ASC").to_sql }
-          it { expect(Spree::Product.limit(2).ascend_by_updated_at.to_sql).to eq Spree::Product.ascend_by_updated_at.limit(2).to_sql }
-        end
-      end
-
-      context 'descend_by_name' do
-        context 'on class' do
-          it { expect(Spree::Product.descend_by_name.to_sql).to eq Spree::Product.order("#{Spree::Product.quoted_table_name}.name DESC").to_sql }
-        end
-
-        context 'on ActiveRecord::Relation' do
-          it { expect(Spree::Product.limit(2).descend_by_name.to_sql).to eq Spree::Product.limit(2).order("#{Spree::Product.quoted_table_name}.name DESC").to_sql }
-          it { expect(Spree::Product.limit(2).descend_by_name.to_sql).to eq Spree::Product.descend_by_name.limit(2).to_sql }
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/product_duplicator_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-module Spree
-
-  describe Spree::ProductDuplicator, :type => :model do
-
-    let(:product) { create(:product, properties: [create(:property, name: "MyProperty")])}
-    let!(:duplicator) { Spree::ProductDuplicator.new(product)}
-
-    let(:image) { File.open(File.expand_path('../../../fixtures/thinking-cat.jpg', __FILE__)) }
-    let(:params) { {:viewable_id => product.master.id, :viewable_type => 'Spree::Variant', :attachment => image, :alt => "position 1", :position => 1} }
-
-    before do
-      Spree::Image.create(params)
-    end
-
-    it "will duplicate the product" do
-      expect{duplicator.duplicate}.to change{Spree::Product.count}.by(1)
-    end
-
-    context 'when image duplication enabled' do
-
-      it "will duplicate the product images" do
-        expect{duplicator.duplicate}.to change{Spree::Image.count}.by(1)
-      end
-
-    end
-
-    context 'when image duplication disabled' do
-
-      let!(:duplicator) { Spree::ProductDuplicator.new(product, false) }
-
-      it "will not duplicate the product images" do
-        expect{duplicator.duplicate}.to change{Spree::Image.count}.by(0)
-      end
-
-    end
-
-    context 'image duplication default' do
-
-      context 'when default is set to true' do
-
-        it 'clones images if no flag passed to initializer' do
-          expect{duplicator.duplicate}.to change{Spree::Image.count}.by(1)
-        end
-
-      end
-
-      context 'when default is set to false' do
-
-        before do
-          ProductDuplicator.clone_images_default = false
-        end
-
-        after do
-          ProductDuplicator.clone_images_default = true
-        end
-
-        it 'does not clone images if no flag passed to initializer' do
-          expect{ProductDuplicator.new(product).duplicate}.to change{Spree::Image.count}.by(0)
-        end
-
-      end
-
-    end
-
-    context "product attributes" do
-      let!(:new_product) {duplicator.duplicate}
-
-      it "will set an unique name" do
-        expect(new_product.name).to eql "COPY OF #{product.name}"
-      end
-
-      it "will set an unique sku" do
-        expect(new_product.sku).to include "COPY OF SKU"
-      end
-
-      it "copied the properties" do
-        expect(new_product.product_properties.count).to be 1
-        expect(new_product.product_properties.first.property.name).to eql "MyProperty"
-      end
-    end
-
-    context "with variants" do
-      let(:option_type) { create(:option_type, name: "MyOptionType")}
-      let(:option_value1) { create(:option_value, name: "OptionValue1", option_type: option_type)}
-      let(:option_value2) { create(:option_value, name: "OptionValue2", option_type: option_type)}
-
-      let!(:variant1) { create(:variant, product: product, option_values: [option_value1]) }
-      let!(:variant2) { create(:variant, product: product, option_values: [option_value2]) }
-
-      it  "will duplciate the variants" do
-        # will change the count by 3, since there will be a master variant as well
-        expect{duplicator.duplicate}.to change{Spree::Variant.count}.by(3)
-      end
-
-      it "will not duplicate the option values" do
-        expect{duplicator.duplicate}.to change{Spree::OptionValue.count}.by(0)
-      end
-
-    end
-  end
-end